RocketMQ使用

最新推荐文章于 2024-06-20 19:50:41 发布
最新推荐文章于 2024-06-20 19:50:41 发布
阅读量1.2k 收藏 5
点赞数
分类专栏： ActiveMQ JMS 文章标签： RocketMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013310119/article/details/90714463
版权

消息发送端（客户端）代码结构：

RocketMQ配置文件：

rocketmq.properties

#wbw 2016.8.22

#rocketmq的NameServer地址
#rocketmq.namesrvAddr=10.104.102.22:9876
#rocketmq.namesrvAddr=127.0.0.1:9876
rocketmq.namesrvAddr=10.**.***.**:9876

#rocketmq生产者配置
#rocketmq的ProducerGroupName，需要由应用来保证唯一。发送普通的消息时，作用不大，但是发送分布式事务消息时，服务器会回查这个Group下的任意一个Producer
rocketmq.producerGroup=InspurTaxMQProducer

#rocketmq消费者配置
#rocketmq的ConsumerGroupName，需要由应用来保证唯一。
rocketmq.consumerGroup=InspurTaxMQConsumer
#rocketmq消费者订阅情况格式为topic:tag1||tag2,topic2:*,topic3:tag3(多个tag用'||'分隔，'*'代表不过滤tag)
rocketmq.subscribes=TestTopic:test||test2,TestTopic2:*
#rocketmq最小消费者线程数(默认:20)
rocketmq.consumeThreadMin=20
#rocketmq最大消费者线程数(默认:64)
rocketmq.consumeThreadMax=64
#rocketmq批量接收消息的数量(默认:1)
rocketmq.consumeMessageBatchMaxSize=1
#rocketmq是否广播消费模式(默认:false)
rocketmq.isBroadcasting=false
#rocketmq消息最大长度（256KB）
rocketmq.maxMessageSize=2621440000
#队列初始个数(weblogic集群节点数加1)
rocketmq.queueNum=10

 mq.properties文件：

#producer
#每个集群节点配置单独的监听队列
default=4
Server_sstww=4
M1=1
M2=2
M3=3
M4=4

Code.java和CodeCenter.java定义了MQ状态码集：

package com.inspur.tax.common.rocketmq.data;
/**
 * Title: Code.java
 * Description: MQ状态代码集
 */
public class Code {
	/**
	 * 大类状态代码
	 */
	//正常返回
	public static final String SUCCESS_CODE = "0";
	//异常返回
	public static final String FAIL_CODE = "1";
	/**
	 * 小类状态代码
	 */
	//成功
	public static final String CODE_0000 = "0000";
	//Server execute business method error
	public static final String CODE_0001 = "0001";
	//Send message fail
	public static final String CODE_0010 = "0010";
	//wait timeout
	public static final String CODE_0011 = "0011";
	//recived message body is empty
	public static final String CODE_0012 = "0012";
	//JsonUtil.jsonStrToObject error
	public static final String CODE_0013 = "0013";
}

package com.inspur.tax.common.rocketmq.data;
/**
 * Title: CodeCenter.java
 * Description: MQ状态代码集
 */
public class CodeCenter {
	public static String getInfo(String id) {
		String result = "";
		switch (Integer.parseInt(id)) {
		case 0001: {
			result = "Server execute business method error";
			break;
		}
		case 0010: {
			result = "Send message fail";
			break;
		}
		case 0011: {
			result = "wait timeout";
			break;
		}
		case 0012: {
			result = "recived message body is empty";
			break;
		}
		case 0013: {
			result = "JsonUtil.jsonStrToObject error";
			break;
		}
		case 9999: {
			result = "Unknown error";
			break;
		}
		default: {
			result = "Unknown error";
			break;
		}
		}
		return result;
	}
}

MessageProperty.java为MQ读取配置文件获取配置信息的方法：

package com.inspur.tax.common.rocketmq;

import java.io.IOException;
import java.util.Properties;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.rocketmq.common.protocol.heartbeat.MessageModel;
import com.inspur.tax.utils.PropertiesLoader;

public class MessageProperty {

	private final static Logger log = LoggerFactory.getLogger(MessageProperty.class);
	private static final PropertiesLoader rocketmqProperties = new PropertiesLoader("rocketmq.properties");

	/**
	 * 从配置文件rocketmq.properties中获取namesrvAddr
	 */
	public static final String namesrvAddr = rocketmqProperties.getProperty("rocketmq.namesrvAddr");
	
	public static final String isBroadcasting = rocketmqProperties.getProperty("rocketmq.isBroadcasting");
	
//	public static final int maxMessageSize = Integer.parseInt(rocketmqProperties.getProperty("rocketmq.maxMessageSize"));
	/**
	 * 队列个数(weblogic集群节点数加1)
	 */
	public static final int queueNum = Integer.parseInt(rocketmqProperties.getProperty("rocketmq.queueNum"));

	public static final String producerGroup = "producerGroup_ww";

	public static final String consumerGroup = "consumerGroup_ww";
	
	public static final String producerInstanceName = producerGroup + String.valueOf(System.currentTimeMillis());
	
	public static final String consumerInstanceName = consumerGroup + String.valueOf(System.currentTimeMillis());
	
	
	/**
	  * Title: getQueueId 
	  * Description: producer
	  * Param @return
	  * Param @throws Exception
	  * Return int[]
	  * Modify: GongZhf 2017年2月19日上午10:33:07 TODO
	 */
	public static int getQueueId() throws Exception{
		int queueId = -1;
		String queueIdStr = null;
		String sysParam = System.getProperty("weblogic.Name");
		if(log.isInfoEnabled()){
			log.info("[property]sysParam..."+sysParam);
		}
		if(sysParam == null){
			if(log.isInfoEnabled()){
				log.info("[property]param [weblogic.Name] not found,try to get [default]...");
			}
			queueIdStr = getPropertie().getProperty("default");
		}else if(getPropertie().getProperty(sysParam) == null){
			if(log.isInfoEnabled()){
				log.info("[property]["+sysParam+"] not found in mq.properties,try to get [default]...");
			}
			queueIdStr = getPropertie().getProperty("default");
		}else{
			queueIdStr = getPropertie().getProperty(sysParam);
		}
		if(log.isInfoEnabled()){
			log.info("[property]queueId..."+queueIdStr);
		}
		if(queueIdStr != null){
			queueId = Integer.parseInt(queueIdStr);
		}else{
			if(log.isErrorEnabled()){
				log.error("[property]weblogic.Name["+sysParam+"]does not match the cluster serverName...");
			}
			throw new Exception("[property]weblogic.Name["+sysParam+"]does not match the cluster serverName...");
		}
		return queueId;
	}
	public static MessageModel getMessageModel(){
		return isBroadcasting.equals("false") ? MessageModel.CLUSTERING : MessageModel.BROADCASTING;
	}
	public static Properties getPropertie() {
		Properties property = new Properties();
		try {
			Class<MessageProperty> myClass = MessageProperty.class;
			property.load(myClass.getResource("mq.properties").openStream());
		} catch (IOException e) {
			e.printStackTrace();
		}
		return property;
	}
}

Consumer消费者：

package com.inspur.tax.common.rocketmq.factory;

import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer;
import com.alibaba.rocketmq.client.exception.MQClientException;
import com.alibaba.rocketmq.common.consumer.ConsumeFromWhere;
import com.inspur.tax.common.rocketmq.MessageProperty;
/**
 * Title: Consumer.java
 * Description: TODO
 * Date: 2017年3月2日下午4:14:07
 * Author: GongZhf
 * modify：GongZhf 2017年3月2日下午4:14:07 TODO
 */
public class Consumer {
	private static DefaultMQPushConsumer consumer = null;
	
	static{
		if(consumer == null){
			consumer = new DefaultMQPushConsumer(MessageProperty.consumerGroup);
			consumer.setNamesrvAddr(MessageProperty.namesrvAddr);
			consumer.setMessageModel(MessageProperty.getMessageModel());
			try {
				consumer.subscribe("MQ_RESPONSE_TOPIC", "MQ_RESPONSE_TAG");
				// 程序第一次启动从消息队列头取数据
				consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
			} catch (MQClientException e) {
				e.printStackTrace();
			}
		}
	}
	public static DefaultMQPushConsumer getInstance(){
		return consumer;
	}
	public static void setConsumer(DefaultMQPushConsumer consumer) {
		Consumer.consumer = consumer;
	}
}

Producer生产者：

package com.inspur.tax.common.rocketmq.factory;

import com.alibaba.rocketmq.client.exception.MQClientException;
import com.alibaba.rocketmq.client.producer.DefaultMQProducer;
import com.inspur.tax.common.rocketmq.MessageProperty;
/**
 * Title: Producer.java
 * Description: TODO
 */
public class Producer {
	private static DefaultMQProducer producer = null;
	
	static{
		if(producer == null){
			producer = new DefaultMQProducer(MessageProperty.producerGroup);
			producer.setInstanceName(MessageProperty.producerInstanceName);
			producer.setNamesrvAddr(MessageProperty.namesrvAddr);
//			producer.setMaxMessageSize(MessageProperty.maxMessageSize);
			try {
				producer.start();
//				producer.createTopic("WW_REQUEST_TOPIC", "WW_REQUEST_TAG", MessageProperty.queueNum);
			} catch (MQClientException e) {
				e.printStackTrace();
			}
		}
	}
	public static DefaultMQProducer getInstance(){
		return producer;
	}
	public static void setProducer(DefaultMQProducer producer) {
		Producer.producer = producer;
	}
}

MqUtil为MQ消息发送公共类：

package com.inspur.tax.common.rocketmq.util;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.rocketmq.client.producer.DefaultMQProducer;
import com.alibaba.rocketmq.client.producer.MessageQueueSelector;
import com.alibaba.rocketmq.client.producer.SendResult;
import com.alibaba.rocketmq.client.producer.SendStatus;
import com.alibaba.rocketmq.common.message.Message;
import com.alibaba.rocketmq.common.message.MessageQueue;
import com.inspur.tax.common.rocketmq.MessageProperty;
import com.inspur.tax.common.rocketmq.data.Code;
import com.inspur.tax.common.rocketmq.data.CodeCenter;
import com.inspur.tax.common.rocketmq.factory.Producer;
import com.inspur.tax.utils.StringUtils;
import com.inspur.tax.utils.json.JsonInput;
import com.inspur.tax.utils.json.JsonOutput;
import com.inspur.tax.utils.json.JsonUtil;
/**
 * Title: MqUtil.java
 * Description: MQ发送入口
 * Date: 2017年3月2日下午4:12:21
 * Author: GongZhf
 * modify：GongZhf 2017年3月2日下午4:12:21 TODO
 */
public class MqUtil {
	private static final Logger log = LoggerFactory.getLogger(MqUtil.class);
	public static Map<String,BlockingQueue<Object>> globalMap = new HashMap<String,BlockingQueue<Object>>();
	
	public static JsonOutput sendMessage(JsonInput inputJson) {
		Object result = null;
		JsonOutput jsonOutput = null;
		DefaultMQProducer producer = Producer.getInstance();
		try {
			inputJson.setQueueId(MessageProperty.getQueueId());
			String requestJson = JsonUtil.objectToJsonStr(inputJson);
			String keys = StringUtils.getUUID();
			Message msg = new Message("WW_REQUEST_TOPIC", "WW_REQUEST_TAG", keys, requestJson.getBytes());
			//SendResult sendResult = producer.send(msg);
			SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
				@Override
				public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
					return mqs.get(Integer.parseInt(String.valueOf(arg)));// 发送给指定的队列
				}
			}, MessageProperty.getQueueId());
			if(sendResult.getSendStatus().equals(SendStatus.SEND_OK)){
				if(log.isInfoEnabled()){
					log.info("[MqUtil]send ok...keys..." + keys);
				}
				BlockingQueue<Object> bq = new ArrayBlockingQueue<Object>(1);
				globalMap.put(keys, bq);
				
				result = bq.poll(60, TimeUnit.SECONDS);
				if (result == null) {
					jsonOutput = new JsonOutput(
							new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()), 
							inputJson.getTranSeq(), 
							inputJson.getTranId(), 
							Code.FAIL_CODE, 
							Code.CODE_0011, 
							CodeCenter.getInfo(Code.CODE_0011), 
							inputJson.getSignatureInfo(), 
							new ArrayList<Map<String, Object>>());
					if(log.isErrorEnabled()){
						log.error("[MqUtil]BlockingQueue wait timeout...keys..." + keys);
					}
				}else if(result.toString().equals("empty")){
					jsonOutput = new JsonOutput(
							new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()), 
							inputJson.getTranSeq(), 
							inputJson.getTranId(), 
							Code.FAIL_CODE, 
							Code.CODE_0012, 
							CodeCenter.getInfo(Code.CODE_0012), 
							inputJson.getSignatureInfo(), 
							new ArrayList<Map<String, Object>>());
					if(log.isErrorEnabled()){
						log.error("[MqUtil]recived message body is empty...keys..." + keys);
					}
				}else{
					if(log.isInfoEnabled()){
						log.info("[MqUtil]recived success...keys..." + keys + "...result..." + (String)result);
					}
					jsonOutput = JsonUtil.jsonStrToObject((String)result, JsonOutput.class);
					if(jsonOutput == null){
						jsonOutput = new JsonOutput(
								new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()), 
								inputJson.getTranSeq(), 
								inputJson.getTranId(), 
								Code.FAIL_CODE, 
								Code.CODE_0013, 
								CodeCenter.getInfo(Code.CODE_0013), 
								inputJson.getSignatureInfo(), 
								new ArrayList<Map<String, Object>>());
						if(log.isErrorEnabled()){
							log.error("[MqUtil]JsonUtil.jsonStrToObject error...keys..." + keys);
						}
					}
				}
				globalMap.remove(keys);
			}else{
				jsonOutput = new JsonOutput(
						new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()), 
						inputJson.getTranSeq(), 
						inputJson.getTranId(), 
						Code.FAIL_CODE, 
						Code.CODE_0010, 
						CodeCenter.getInfo(Code.CODE_0010), 
						inputJson.getSignatureInfo(), 
						new ArrayList<Map<String, Object>>());
				if(log.isErrorEnabled()){
					log.error("[MqUtil]send message fail...keys..." + keys);
				}
			}
		} catch (Exception e) {
			if(log.isErrorEnabled()){
				log.error("[MqUtil]mq error...errorMessage..." + e.getMessage());
			}
			e.printStackTrace();
		}
		return jsonOutput;
	}
}

MessageListener为消息发送到（客户端）的MQ监听类，监听MQ服务器返回来的消息放入BlockingQueue特殊队列中：MQUtil类中通过

BlockingQueue<Object> bq = new ArrayBlockingQueue<Object>(1);
                globalMap.put(keys, bq);
                
                result = bq.poll(60, TimeUnit.SECONDS);

来等待60秒获取指定key的消息返回值（Key一般用消息在业务层面的唯一标识码，可以方便后续跟踪查询，尽量保证Key的唯一性）

消息接受端（服务端）代码结构：

MQ配置文件读取、状态码集、消费者、生产者、消息监听器、Mqutil公共类和发送端的代码总体上一致，唯一不同的为

MessageListener类和MqUtil类代码如下：

package com.inspur.tax.common.rocketmq.listener;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.loushang.framework.util.SpringContextHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.rocketmq.client.consumer.AllocateMessageQueueStrategy;
import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer;
import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import com.alibaba.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import com.alibaba.rocketmq.common.message.MessageExt;
import com.alibaba.rocketmq.common.message.MessageQueue;
import com.inspur.tax.common.rocketmq.data.Code;
import com.inspur.tax.common.rocketmq.data.CodeCenter;
import com.inspur.tax.common.rocketmq.factory.Consumer;
import com.inspur.tax.common.rocketmq.util.MqUtil;
import com.inspur.tax.sst.common.service.impl.ManagerCenterMQService;
import com.inspur.tax.utils.json.JsonInput;
import com.inspur.tax.utils.json.JsonOutput;
import com.inspur.tax.utils.json.JsonUtil;

/**
 * Title: MessageListener.java Description: MQ监听 Date: 2017年3月2日下午4:12:35
 * Author: GongZhf modify：GongZhf 2017年3月2日下午4:12:35 TODO
 */
public class MessageListener implements ServletContextListener {

	private static final Logger log = LoggerFactory.getLogger(MessageListener.class);
	private static final DefaultMQPushConsumer consumer = Consumer.getInstance();

	@Override
	public void contextDestroyed(ServletContextEvent arg0) {
		consumer.shutdown();
		Consumer.setConsumer(null);
	}
	@Override
	public void contextInitialized(ServletContextEvent arg0) {
		if (log.isInfoEnabled()) {
			log.info("[MessageListener]listener starting...");
		}
		try {
			/**
			 * 生产没有setAllocateMessageQueueStrategy方法
			 */
			consumer.setAllocateMessageQueueStrategy(new AllocateMessageQueueStrategy() {
				@Override
				public String getName() {
					return consumer.getConsumerGroup();
				}

				@Override
				public List<MessageQueue> allocate(String consumerGroup, String currentCID, List<MessageQueue> mqAll,
						List<String> cidAll) {
					List<MessageQueue> submq = new ArrayList<MessageQueue>();
					for (MessageQueue mq : mqAll) {
						if (mq.getQueueId() == 4) {
							submq.add(mq);
						}
					}
					return submq;
				}
			});
			consumer.registerMessageListener(new MessageListenerConcurrently() {
				public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
						ConsumeConcurrentlyContext context) {
					MessageExt msgExt = (MessageExt) msgs.get(0);
					String keys = msgExt.getKeys();
					String body = new String(msgExt.getBody());
					if (log.isInfoEnabled()) {
						log.info("[MessageListener]server listened keys..." + keys + "...msgExt...."
								+ msgExt.toString());
						log.info("[MessageListener]server listened keys..." + keys + "....body....." + body);
					}
					String responseJson = null;
					JsonOutput outputJson = null;
					JsonInput inputJson = JsonUtil.jsonStrToObject(body, JsonInput.class);
					try {
						ManagerCenterMQService mcService = (ManagerCenterMQService) SpringContextHolder
								.getBean("managerCenterMQService");
						responseJson = mcService.execute(body);
						if (log.isInfoEnabled()) {
							log.info("[MessageListener]server execute business method success... keys......" + keys
									+ "...responseJson..." + responseJson);
						}
						outputJson = JsonUtil.jsonStrToObject(responseJson, JsonOutput.class);
					} catch (Exception e) {
						outputJson = new JsonOutput(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()),
								inputJson.getTranSeq(), inputJson.getTranId(), Code.FAIL_CODE, Code.CODE_0001,
								CodeCenter.getInfo(Code.CODE_0001), inputJson.getSignatureInfo(),
								new ArrayList<Map<String, Object>>());
						if (log.isErrorEnabled()) {
							log.error("[MessageListener]server execute business method error......keys..." + keys
									+ "...errorMessage..." + e.getMessage());
						}
						e.printStackTrace();
					}
					transmitMessage(inputJson.getQueueId(), keys, outputJson);
					return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
				}
			});
			consumer.start();
		} catch (Exception e) {
			e.printStackTrace();
			if (log.isErrorEnabled()) {
				log.error("[MessageListener]server registerMessageListener error...errorMessage..." + e.getMessage());
			}
		}
	}

	public void transmitMessage(int queueId, String keys, JsonOutput outputJson) {
		MqUtil.sendMessage(queueId, keys, outputJson);
	}
}

package com.inspur.tax.common.rocketmq.util;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.BlockingQueue;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.rocketmq.client.producer.DefaultMQProducer;
import com.alibaba.rocketmq.client.producer.MessageQueueSelector;
import com.alibaba.rocketmq.client.producer.SendResult;
import com.alibaba.rocketmq.client.producer.SendStatus;
import com.alibaba.rocketmq.common.message.Message;
import com.alibaba.rocketmq.common.message.MessageQueue;
import com.inspur.tax.common.rocketmq.factory.Producer;
import com.inspur.tax.utils.json.JsonOutput;
import com.inspur.tax.utils.json.JsonUtil;
/**
 * Title: MqUtil.java
 * Description: TODO
 * Date: 2017年3月2日下午4:13:33
 * Author: GongZhf
 * modify：GongZhf 2017年3月2日下午4:13:33 TODO
 */
public class MqUtil {
	private static final Logger log = LoggerFactory.getLogger(MqUtil.class);
	public static Map<String,BlockingQueue<Object>> globalMap = new HashMap<String,BlockingQueue<Object>>();
	
	public static void sendMessage(int queueId, String keys, JsonOutput outputJson) {
		try {
			final DefaultMQProducer producer = Producer.getInstance();
			String requestJson = JsonUtil.objectToJsonStr(outputJson);
			Message msg = new Message("MQ_RESPONSE_TOPIC", "MQ_RESPONSE_TAG", keys, requestJson.getBytes());
			SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
				@Override
				public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
					return mqs.get(Integer.parseInt(String.valueOf(arg)));// 发送给指定的队列
				}
			}, queueId);
			if(sendResult.getSendStatus().equals(SendStatus.SEND_OK)){
				if(log.isInfoEnabled()){
					log.info("[MqUtil]server send success...key..." + keys + "...queueId..." + queueId);
				}
			}else{
				if(log.isErrorEnabled()){
					log.error("[MqUtil]server sendStatus not ok...key..." + keys + "...queueId..." + queueId + "...sendStatus..." + sendResult.getSendStatus());
				}
			}
		} catch (Exception e) {
			if(log.isErrorEnabled()){
				log.error("[MqUtil]server send error...key..." + keys + "...queueId..." + queueId + "...errorMessage..." + e.getMessage());
			}
			e.printStackTrace();
		}
	}
}

 

在服务端发送返回消息时需要注意queueID和keys应该和客户端一致。

李晓LOVE向阳
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RocketMQ 使用
qq_33753147的博客
09-27 2908
RocketMQ 使用
RocketMQ使用手册
06-21
"RocketMQ 使用手册" RocketMQ 是一款分布式、队列模型的消息中间件，具有以下特点： * 能够保证严格的消息顺序 * 提供丰富的消息拉取模式 * 高效的订阅者水平扩展能力 * 实时的消息订阅机制 * 亿级消息堆积能力 ...
RocketMQ使用指南
技术人集结地
12-08 934
RocketMQ是一款由阿里巴巴公司开发的开源分布式消息中间件，于2012年开始开发。它具有高可用性、高性能、可靠性强、功能丰富等特点，广泛应用于电商、金融、物流、互联网和大数据等领域。RocketMQ支持生产者和消费者的负载均衡、数据分片、数据重试、数据过期等特性，同时还支持消息的事务、顺序消费、定时消费、广播消费等高级特性。RocketMQ的消息存储采用了基于CommitLog的方式，保证消息的可靠存储和高效读取。
详解RocketMQ使用
Joker_ZJN的博客
07-15 3419
一文详解RocketMQ的顺序模式、广播模式、延迟消息、批量消息、过滤消息、事务消息
RocketMQ介绍
最新发布
迷失蒲公英
06-20 955
Apache Alibaba RocketMQ是阿里巴巴开源的一个消息中间件，在阿里内部历经了双十一等很多高并发场景的考验，能够处理亿万级别的消息。2016年开源后捐赠给Apache，现在是Apache的一个顶级项目。 由Java语言开发，底层采用Netty通信。 目前客户端支持Java, C++, Go。
RocketMQ 使用入门案例
冒险的梦想家的博客~
02-01 2322
SpringCloud Alibaba RocketMQ RocketMQ概述 RocketMQ是一款由阿里研发的高性能高可靠性的分布式消息队列，使用Java语言开发，该项目已经贡献给了Apache基金会，成为Apache的顶级开源项目。 在早期，阿里内部使用ActiveMQ作为其消息传递中间件，随着业务的快速增长，基于ActiveMQ的消息队列集群在处理大规模业务吞吐量时会遇到IO等性能瓶颈，阿里研发团队曾努力优化ActiveMQ，但无奈效果不理想，紧接着他们将目光投向Kafka，不幸的是Kafka并不能
RocketMQ使用（1）：介绍与启动
游王子的博客
05-22 824
消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题。实现高性能，高可用，可伸缩和最终一致性架构。使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ等。RocketMQ是阿里研发的一个队列模型的消息中间件，后开源给apache基金会成为了apache的顶级开源项目，具有高性能、高可靠、高实时、分布式特点。
RocketMq使用教程
weixin_41572449的博客
07-21 7398
简介： 基于windows 下的使用教程 1-下载安装rocket https://www.apache.org/dyn/closer.cgi?path=rocketmq/4.9.0/rocketmq-all-4.9.0-bin-release.zip 2-配置环境变量：ROCKETMQ_HOME =(解压位置) D:\rocket\rocketmq-all-4.9.0-bin-release 3-启动 mqnamesrv 服务 进入 D:\rocket\rocketmq-all-4.9.0-bin-rel
rocketmq使用mqtt协议
文若书生的专栏
07-13 6290
rocketmq从4.9.3开始，可以兼容mqtt协议，需要安装编译一个rocketmq-mqtt工程，参考：https://rocketmq.apache.org/zh/docs/4.x/mqtt/02RocketMQMQTTQuickStart/需要安装rocketmq4.9.3以上的版本 安装过程略broker.conf配置文件中添加参数，开启多队列分发特性 二、打包rocketmq-mqtt 安装maven配置环境变量 过程略 下载并打包 三、配置rocketmq-mqtt 下面例子中 ROCKET
RocketMQ使用过程中需要注意的点
mizepeng的博客
12-20 464
RocketMQ使用过程中需要注意的点
rocketmq使用.zip
02-21
本压缩包“rocketmq使用.zip”包含了关于RocketMQ使用和事务消息的相关资料，让我们一起来深入探讨这些知识点。 首先，我们要理解RocketMQ的基本概念和架构。RocketMQ的核心组件包括Producer、Consumer、NameServer...
rocketmq使用手册
08-29
### RocketMQ 使用手册 #### 一、RocketMQ 简介及特性 RocketMQ 是一款高性能、可扩展的分布式消息中间件，它被设计用于解决大规模互联网应用中的消息传输问题。该中间件具备以下特点： 1. **严格的消息顺序保证*...
RocketMQ使用与实现.pdf
03-09
### RocketMQ 使用与实现知识点详解 #### 一、RocketMQ简介 - **定义**：RocketMQ是一款由阿里巴巴研发并开源的分布式消息中间件，具备高度可靠性和灵活性，被广泛应用于大规模分布式系统中。 - **核心特性**： - ...
Oracle数据库BLOB字段转换成inputStream输入流然后转换成字符串，然后从字符串转换成流输出到指定目录（Weblogic JMS传递）
崔向阳@李晓的博客
09-04 2506
工具类：流转字符串工具类 import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileO...
WebLogic跨域访问安全问题
崔向阳@李晓的博客
05-24 2028
问题描述：在外网有一台113的机器上面有一个7001的weblogic服务，上面搭建了weblogic JMS服务器。在内网同一样有一台机器作为JMS消息的消费者和生产者，要从外网113机器的JMS消息队列接收消息，并处理结束后，向外网113机器的JMS返回消息队列发送一条消息。这时部署完工程以后，启动，就出现了Weblogic跨域的问题。1、错误描述1.1、jms服务端不停的报：&lt;2013...
Linux环境下搭建Weblogic集群以及配置Weblogic JMS集群
崔向阳@李晓的博客
10-31 1524
问题背景：最近公司使用Weblogic中间件服务器自带的JMS作为消息服务器，来进行内外网消息的传递，之前一直是在一台机器上搭建的Weblogic JMS，用来进行收发消息。进来由于客户考虑到并发以及单个服务器作为JMS服务器的可靠性不高，由此建议搭建Weblogic JMS集群。 问题解决步骤： 我从网上收集了很多资料并尝试，并成功搭建了Weblogic 集群并在上面创建Weblogic J...
rocketmq使用
09-26
在开发中使用rocketmq-spring-boot-starter可以快速集成RocketMQ并搭建集成环境。但是该框架并不完全具备RocketMQ的所有配置简化，如果需要批量消费消息，需要自定义一个DefaultMQPushConsumer bean去消费消息。你...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

李晓LOVE向阳

你的鼓励是我持续的不断动力

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

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

打赏作者

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

抵扣说明：

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

余额充值