Rocket MQ原生代码

最新推荐文章于 2024-08-20 23:45:00 发布

happyu新晋码农

最新推荐文章于 2024-08-20 23:45:00 发布

阅读量264

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_42546038/article/details/121486182

版权

1.首先需要将消息序列化处理工具类被序列化的对象必须实现Serializable接口

package com.itheima.common.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * @author: itheima
 * @create: 2021-07-30 12:39
 */
public class ByteUtil {

    /**
     * 对象转byte
     * @param obj
     * @return
     */
    public static byte[] ObjectToByte(Object obj) {
        byte[] bytes = null;
        try {
            // object to bytearray
            ByteArrayOutputStream bo = new ByteArrayOutputStream();
            ObjectOutputStream oo = new ObjectOutputStream(bo);
            oo.writeObject(obj);

            bytes = bo.toByteArray();

            bo.close();
            oo.close();
        } catch (Exception e) {
            System.out.println("translation" + e.getMessage());
            e.printStackTrace();
        }
        return bytes;
    }

    /**
     * byte转对象
     * @param bytes
     * @return
     */
    public static Object ByteToObject(byte[] bytes) {
        Object obj = null;
        try {
            // bytearray to object
            ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
            ObjectInputStream oi = new ObjectInputStream(bi);

            obj = oi.readObject();
            bi.close();
            oi.close();
        } catch (Exception e) {
            System.out.println("translation" + e.getMessage());
            e.printStackTrace();
        }
        return obj;
    }
}

2.生产者发送消息

/**
     * 更新用户表信息；向指定手机设备发送推送通知
     *
     * @param userJoinCompanyDTO
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void applyJoinCompany(UserJoinCompanyDTO userJoinCompanyDTO) throws MQClientException, RemotingException, InterruptedException, MQBrokerException {
       
            DefaultMQProducer producer = new DefaultMQProducer("producerGroup");
 //        设置NameServe地址，如果是集群环境，用分号隔开
            producer.setNamesrvAddr("127.0.0.1:9876");
//        启动并创建消息发送组件
            producer.start();
//      要发送的数据 byte[]  notifyMessage必须要实现序列化接口
//          
            Message message = new Message(PUSH_TOPIC_NAME, RocketMQConstants.TAGS.USER_APPLY_TAGS, ByteUtil.ObjectToByte(notifyMessage));
            // 发送消息
            SendResult result = producer.send(message);
            System.out.println(result);

        }
    }

3.消费者监听

package com.itheima.notify.listener;

import com.itheima.common.constants.RocketMQConstants;
import com.itheima.common.util.ByteUtil;
import com.itheima.notify.dto.NotifyMessage;
import com.itheima.notify.service.NotifyMessageService;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.autoconfigure.RocketMQProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import springfox.documentation.spring.web.json.Json;

import java.util.List;

/**
 * @author: itheima
 * @create: 2021-07-30 12:47
 */
@Component
public class Consumer {



    @Autowired
    private NotifyMessageService notifyMessageService;


    public Consumer() throws MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(RocketMQConstants.CONSUMER.NOTIFY_MSG_CONSUMER);
        consumer.setNamesrvAddr("127.0.0.1:9876");
        consumer.subscribe(RocketMQConstants.TOPIC.PUSH_TOPIC_NAME, "*");
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                try {
                    MessageExt messageExt = msgs.get(0);
                    byte[] body = messageExt.getBody();
                    NotifyMessage notifyMessage = (NotifyMessage) ByteUtil.ByteToObject(body);
                    notifyMessageService.sendMsgToUser(notifyMessage);
                    //基于Redis或者数据库 保证消费幂等性
                } catch (Exception e) {
                    //出现消费错误重试 重试次数超过三次，将消息执行结果存入数据库中，定时任务扫描失败任务进行重试，或者人工
                    return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        System.out.println("消费者 启动成功=======");
        consumer.start();
    }

}