RocketMQ java初级使用

Mr.4567

于 2024-07-23 15:59:20 发布

阅读量285

点赞数 3

CC 4.0 BY-SA版权

文章标签： java-rocketmq rocketmq java

本文链接：https://blog.youkuaiyun.com/qq_33651286/article/details/140638341

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
* @author wp
* 创建时间：2021年3月8日 下午3:01:35
* 项目名称：smart_reception
* @version 1.0
* @since JDK 1.8
* 文件名称：RocketMQPubService.java
* 类说明：RocketMQ指令发送器
*/
public class RocketMQPubService {
	private static Logger log = LoggerFactory.getLogger(RocketMQPubService.class);
	
	//host port
	private String namesrvAddr = RocketMQPropertiesUtils.getString("rocketmq.namesrvAddr");
	//生成者组名
	private String producerGroupName = RocketMQPropertiesUtils.getString("rocketmq.producerGroupName");
	private DefaultMQProducer producer;
	
	
	private static RocketMQPubService service;
	
	
	private RocketMQPubService(){
		init();
	}
	
	
	public static RocketMQPubService getInstance(){
		if (service == null){
			service = new RocketMQPubService();
		}
		return service;
	}
	
	
	/**
	 * 初始化实例
	 * @author wp
	 * <p>Title: init<／p>
	 * <p>Description: <／p>
	 * 创建时间：2021年3月12日 上午9:11:16
	 */
	private void init(){
		try {
			producer = new DefaultMQProducer(producerGroupName);
			//设置重试次数(默认2次）
	        producer.setRetryTimesWhenSendFailed(10);
	        //绑定name server
			producer.setNamesrvAddr(namesrvAddr);
			//发送超时时间，默认3000 单位ms
			producer.setSendMsgTimeout(5000);
			producer.start();
		} catch (MQClientException e) {
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 发送信息
	 * @author wp
	 * <p>Title: sendMessage<／p>
	 * <p>Description: <／p>
	 * @param msg
	 * @return
	 * 创建时间：2021年3月12日 上午9:11:09
	 */
	public Boolean sendMessage(Message msg){
		SendResult send;
		try {
			send = producer.send(msg);
			if (send.getSendStatus().equals(SendStatus.SEND_OK)) {
				log.info("信息发送成功！");
				return true;
			}else {
				//发送失败处理
//				init();
//				producer.send(msg);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
        return null;
	}
	public Boolean sendMessage1(Message message) {
		
		try {
			// 2.2 异步发送消息
			producer.send(message, new SendCallback() {
				// rabbitmq急速入门的实战: 可靠性消息投递
				@Override
				public void onSuccess(SendResult sendResult) {
					System.err.println("msgId: " + sendResult.getMsgId() + ", status: " + sendResult.getSendStatus());
				}

				@Override
				public void onException(Throwable e) {
					e.printStackTrace();
					System.err.println("------发送失败");
				}
			});
		} catch (Exception e) {
			// TODO: handle exception
		}
		
		return null;
	}
	
}

package com.cetcnav.GR.rocketMQ;

import java.util.List;

import org.apache.rocketmq.client.consumer.DefaultLitePullConsumer;
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.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.cetcnav.GR.rocketMQ.worker.ListenerServiceWorkerInf;

import org.apache.rocketmq.client.exception.MQClientException;

import cn.hutool.core.collection.CollUtil;

/**
 * @author wp
 * @date 2021年6月3日下午8:00:42
 * @projectName GRDatacenter
 * @fileName RocketMQReceiveThread.java
 * @tags 类说明：接收rocketmq信息
 */
public class RocketMQReceiveThread extends Thread {
	private static Logger log = LoggerFactory.getLogger(RocketMQReceiveThread.class);

	// host port
	private String namesrvAddr = RocketMQPropertiesUtils.getString("rocketmq.namesrvAddr");
	// 指定消费者订阅的主题和标签
	private final String consumerProupName;
	private final String topic;
	private final String tag;
	private final ListenerServiceWorkerInf worker;
	private DefaultMQPushConsumer consumer;

	/**
	 * 
	 * @param consumerProupName
	 *            消费组名
	 * @param topic
	 * @param tag
	 * @param worker
	 */
	public RocketMQReceiveThread(String consumerProupName, String topic, String tag, ListenerServiceWorkerInf worker) {
		super();
		this.consumerProupName = consumerProupName;
		this.topic = topic;
		this.tag = tag;
		this.worker = worker;
	}

	/**
	 * push消费者
	 * 
	 * @author wp
	 *         <p>
	 * 		Title: push<／p>
	 *         <p>
	 * 		Description: <／p>
	 * @throws Exception
	 *             创建时间：2021年3月8日 下午4:40:41
	 */
	public void run() {
		try {
			// 1 创建消费者，指定所属的消费者组名
			consumer = new DefaultMQPushConsumer(consumerProupName);
			// 2 指定NameServer的地址
			consumer.setNamesrvAddr(namesrvAddr);
			// 3 指定消费者订阅的主题和标签 订阅topic和 tags（ * 代表所有标签)下信息
			consumer.subscribe(topic, tag);
			// 一个GroupName第一次消费时的位置
			consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
			consumer.setConsumeThreadMin(20);
			consumer.setConsumeThreadMax(20);
			// 一次最大消费的条数
			consumer.setConsumeMessageBatchMaxSize(10);
			// 消费模式，广播或者集群，默认集群。
			consumer.setMessageModel(MessageModel.CLUSTERING);
			// 在同一jvm中 需要启动两个同一GroupName的情况需要这个参数不一样。
			consumer.setInstanceName("deflate");

			consumer.registerMessageListener(new MessageListenerConcurrently() {
				@Override
				public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
						ConsumeConcurrentlyContext context) {
					worker.handle(msgs);
					log.info("%s Receive New Messages: %s %n", Thread.currentThread().getName(), msgs);
					return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
				}
			});
			consumer.start();
			log.info("Consumer Started.");
		} catch (MQClientException e) {
			e.printStackTrace();
		}
	}

private DefaultLitePullConsumer defaultLitePullConsumer;
	private static boolean runFlag = true;

	/**
	 * pull消费者
	 * 
	 * @author wp
	 *         <p>
	 * 		Title: pull<／p>
	 *         <p>
	 * 		Description: <／p> 创建时间：2021年3月8日 下午6:34:39
	 * @throws Exception
	 */
	public void pull() throws Exception {
		// 1 创建消费者，指定所属的消费者组名
		defaultLitePullConsumer = new DefaultLitePullConsumer(consumerProupName);
		// 2 指定NameServer的地址
		defaultLitePullConsumer.setNamesrvAddr(namesrvAddr);
		// 3 指定消费者订阅的主题和标签
		defaultLitePullConsumer.subscribe(topic, tag);
		// 一次最大消费的条数
		defaultLitePullConsumer.setPullBatchSize(100);

		defaultLitePullConsumer.start();
		while (runFlag) {
			try {
				// 拉取消息，无消息时会阻塞
				List<MessageExt> msgs = defaultLitePullConsumer.poll();
				if (CollUtil.isEmpty(msgs)) {
					continue;
				}
				// 业务处理
				worker.handle(msgs);
				/*
				 * msgs.forEach(msg-> log.info(new String(msg.getBody())) );
				 */
				// 同步消费位置。不执行该方法，应用重启会存在重复消费。
				defaultLitePullConsumer.commitSync();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		defaultLitePullConsumer.shutdown();
	}

}

import com.cetcnav.GR.rocketMQ.RocketMQReceiveThread;
import com.cetcnav.GR.rocketMQ.worker.ReceiveCommandWorker;

/**
 * 
 * @author wp
 * 2021年4月14日上午8:58:34
 * smartReceptionWS
 * DataListener.java
 * 类说明：
 */
public class DataListener {
	
	private static DataListener listener;
	
	public static DataListener getInstance(){
		if (listener == null){
			listener = new DataListener();
		}
		return listener;
	}

	
	/**
	 * 数据接收  预处处理
	 * @author wp 
	 * 2021年4月14日上午8:58:55
	 * @return void
	 */
	public void handle(){
		
		//接收处理前端传过来的指令信息
		ReceiveCommandWorker worker = new ReceiveCommandWorker();
		new RocketMQReceiveThread("command2datacenter", "command2datacenter", "*", worker).start();
	}
	
}

package com.cetcnav.GR.rocketMQ.worker;

import java.util.List;

import org.apache.rocketmq.common.message.MessageExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.cetcnav.GR.base.utils.ByteConvertUtil;
import com.cetcnav.GR.business.cache.TCPChannelManager;

/**
 * @author wp
 * 2021年5月7日下午4:54:52
 * GRDatacenter
 * ReceiveCommandWorker.java
 * 类说明：
 */
public class ReceiveCommandWorker extends ListenerServiceWorkerInf{
	private static Logger log = LoggerFactory.getLogger(ReceiveCommandWorker.class);

	@Override
	public void work(List<MessageExt> msgs) {
		if (msgs != null & msgs.size() != 0){
			log.info("接收到下发指令信息！");
			for (MessageExt msg : msgs){
				byte[] bytes = msg.getBody();
				log.info("接收到下发指令数据帧："+ByteConvertUtil.bytes2HexString(bytes));
				TCPChannelManager.sendMessage(bytes);
				
			}
			
			
		}
		
	}

}

package com.cetcnav.GR.rocketMQ.worker;

import java.util.List;

import org.apache.rocketmq.common.message.MessageExt;

/**
 * 不同的服务之间的信息通信
 * @author Administrator
 *
 */
public abstract class ListenerServiceWorkerInf {
	
	public abstract void work(List<MessageExt> msgs);
	
	public void handle(List<MessageExt> msgs){
		this.work(msgs);
	}
}

发送：



import org.apache.rocketmq.common.message.Message;

import com.cetcnav.GR.business.cache.Datacenter2websocketCache;
import com.cetcnav.GR.rocketMQ.RocketMQPubService;

/**
 * @author wp
 * 2021年4月28日下午7:36:32
 * GRDatacenter
 * Datacenter2websocketWorker.java
 * 类说明：向websocket推送信息
 */
public class Datacenter2websocketWorker implements Runnable{

	@Override
	public void run() {
		while (true){
		//Message msg = new Message("datacenter2websocket",bytes);
			Message msg = Datacenter2websocketCache.take();
			RocketMQPubService.getInstance().sendMessage(msg);
		}
	}

	
	
	
}