com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus Java Examples

@Override
public ConsumeConcurrentlyStatus consumeMessage(String strBody, MessageExt msg,
		ConsumeConcurrentlyContext context)
{
	if (baseMatching != null)
	{
		List<Map<String, String>> me = baseMatching.getMatching();
		if (me != null && me.size() != 0) matching = me;
	}

	for (Map<String, String> map : matching)
	{
		if (forwarded != null) strBody = forwarded.MessageConsumer(strBody, msg, context);
		return sendMqTags(map, msg.getTags(), strBody);
	}
	return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
 

/**
 *    验证规则 并按照规则将数据 转发到对应的 队列中
 */
private ConsumeConcurrentlyStatus sendMqTags(Map<String, String> matchingMap, String MqTags,
		String Mqbody)
{
	// 验证是否有空值
	String[] keys =
	{ "Tag", "body", "Topic", "Tags" };

	try
	{
		ForwardedHelp.outStr(matchingMap, keys);
	}
	catch (Exception e)
	{
		LOGGER.error(" 转发消费端  验证规则 并按照规则将数据 转发到对应的 ", e.getMessage());
		return ConsumeConcurrentlyStatus.RECONSUME_LATER;
	}

	return equalsTag(matchingMap, MqTags, Mqbody);

}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_4");

    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

    consumer.subscribe("TopicTest", "*");

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Consumer Started.");
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupNamecc4");
    /**
     * 使用Java代码，在服务器做消息过滤
     */
    consumer.subscribe("TopicFilter7", MessageFilterImpl.class.getCanonicalName());

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    /**
     * Consumer对象在使用之前必须要调用start初始化，初始化一次即可<br>
     */
    consumer.start();

    System.out.println("Consumer Started.");
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupNamecc4");

    String filterCode = MixAll.file2String("/home/admin/MessageFilterImpl.java");
    consumer.subscribe("TopicFilter7", "com.alibaba.rocketmq.example.filter.MessageFilterImpl",
            filterCode);

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                        ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Consumer Started.");
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_4");
    /**
     * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
     * 如果非第一次启动，那么按照上次消费的位置继续消费
     */
    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

    consumer.subscribe("TopicTest", "*");

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Consumer Started.");
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerGroupNamecc4");
    String filterCode = MixAll.file2String("/home/admin/MessageFilterImpl.java");
    consumer.subscribe("TopicFilter7", "com.alibaba.rocketmq.example.filter.MessageFilterImpl",
        filterCode);

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Consumer Started.");
}
 

/**
 *   匹配 Tag 消息 Tag 的验证
 *   
 * @param matchingMap   注入的  匹配 规则 数据
 * @param MqTags        当前消费的MQ  Tags
 * @param Mqbody		当前转发的 消息 实体
 * @param Topic			需要转发到的 MQ Topic
 * @return
 */
private ConsumeConcurrentlyStatus equalsTag(Map<String, String> matchingMap, String MqTags,
		String Mqbody)
{
	String[] Topic = matchingMap.get("Topic").split(",");

	// 是否需要 匹配 Tag
	if ("*".equals(matchingMap.get("Tag")))
	{
		return equalsbody(matchingMap, MqTags, Mqbody, Topic);// 不需要匹配body
	}
	else
	{
		// 进行匹配 Tag
		if (ForwardedHelp.isContains(MqTags, matchingMap.get("Tag")))
		{
			// 匹配成功 进行 匹配 body
			return equalsbody(matchingMap, MqTags, Mqbody, Topic);
		}
		else
		{
			LOGGER.debug("Tag 匹配未成功 放弃该消息    消息内容是   " + MqTags);
			return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
		}
	}
}
 

/**
 *   匹配 body 消息实体的验证
 *   
 * @param matchingMap   注入的  匹配 规则 数据
 * @param MqTags        当前消费的MQ  Tags
 * @param Mqbody		当前转发的 消息 实体
 * @param Topic			需要转发到的 MQ Topic
 * @return
 */
private ConsumeConcurrentlyStatus equalsbody(Map<String, String> matchingMap, String MqTags,
		String Mqbody, String[] Topic)
{
	// 匹配 body
	if ("*".equals(matchingMap.get("body")))
	{
		// 不需要 匹配 Tag
		return sendMq(matchingMap, Mqbody, Topic);
	}

	if (!ForwardedHelp.isContains(Mqbody, matchingMap.get("body")))
	{
		LOGGER.debug("body 匹配未成功 放弃该消息    消息内容是   " + MqTags);
		return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
	}
	else
	{
		// 转发到MQ
		return sendMq(matchingMap, Mqbody, Topic);
	}
}
 

/**
 *    验证规则 并按照规则将数据 转发到对应的 队列中  
 */
public ConsumeConcurrentlyStatus sendMqTags(Map<String, String> matchingMap, String MqTags,
		Map<String, String> params, String strBody, MessageExt msg,
		ConsumeConcurrentlyContext context)
{
	// 验证是否有空值
	String[] keys =
	{ "url", "Tag", "body" };
	try
	{
		ForwardedHelp.outStr(matchingMap, keys);
	}
	catch (Exception e)
	{
		LOGGER.error(e.getMessage());
		return ConsumeConcurrentlyStatus.RECONSUME_LATER;
	}

	return forwardedWebDate(matchingMap, MqTags, params, msg, context);

}
 

/**
 *  将数据发送给MQ 
 * @param matchingMap   注入的配置数据
 * @param Mqbody	当前消息的 实体
 * @param Topic		转发的队列名称
 */
private ConsumeConcurrentlyStatus sendMq(Map<String, String> matchingMap, String Mqbody,
		String[] Topic)
{
	for (String topicval : Topic)
	{
		try
		{
			if (producer.send(topicval, matchingMap.get("Tags"),
					Mqbody) == null) { return ConsumeConcurrentlyStatus.RECONSUME_LATER; }
			return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
		}
		catch (UnsupportedEncodingException e)
		{
			LOGGER.error(" 转发消费端 异常 转发消息到MQ  失败  Tag= " + matchingMap.get("Topic") + " body= "
					+ Mqbody, e);
			return ConsumeConcurrentlyStatus.RECONSUME_LATER;
		}
	}
	return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_4");

    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

    consumer.subscribe("TopicTest", "*");

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                        ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Consumer Started.");
}
 

public static void main(String[] args) {
    DefaultMQPushConsumer consumer =
            new DefaultMQPushConsumer("PushConsumer");
    consumer.setNamesrvAddr("127.0.0.1:9876");
    try {
        //订阅PushTopic下Tag为push的消息
        consumer.subscribe("PushTopic", "push");
        //程序第一次启动从消息队列头取数据
        consumer.setConsumeFromWhere(
                ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        consumer.registerMessageListener(
                new MessageListenerConcurrently() {
                    @Override
                    public ConsumeConcurrentlyStatus consumeMessage(
                            List<MessageExt> list,
                            ConsumeConcurrentlyContext context) {
                        Message msg = list.get(0);
                        System.out.println(msg.toString());
                        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                    }
                }
        );
        consumer.start();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

@Override
public ConsumeConcurrentlyStatus consumeMessage(String strBody, MessageExt msg,
		ConsumeConcurrentlyContext context)
{

	if (baseMatching != null)
	{
		List<Map<String, String>> me = baseMatching.getMatching();
		if (me != null && me.size() != 0) matching = me;
	}

	// TODO 待完善 日志系统 最简单的方法是 使用 mongodb 存放日志数据
	for (Map<String, String> map : matching)
	{
		Map<String, String> params = new HashMap<String, String>();

		params.put("Topic", msg.getTopic());
		params.put("Tags", msg.getTags());

		if (externalCall == null) params.put("Body", strBody);
		else params.put("Body", externalCall.MessageConsumer(strBody, msg, context));

		return sendMqTags(map, msg.getTags(), params, strBody, msg, context);
	}
	return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;

}
 

@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                ConsumeConcurrentlyContext context) {
    try {
        MetaTuple metaTuple = new MetaTuple(msgs, context.getMessageQueue());

        if (flowControl) {
            sendingQueue.offer(metaTuple);
        } else {
            sendTuple(metaTuple);
        }

        if (autoAck) {
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        } else {
            if (!conf.get(LoadConfig.TOPOLOGY_TYPE).equals("Trident")) {
                metaTuple.waitFinish();
            }
            if (metaTuple.isSuccess()) {
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            } else {
                return ConsumeConcurrentlyStatus.RECONSUME_LATER;
            }
        }

    } catch (Exception e) {
        LOG.error("Failed to emit " + id, e);
        return ConsumeConcurrentlyStatus.RECONSUME_LATER;
    }

}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_1");
    /**
     * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
     * 如果非第一次启动，那么按照上次消费的位置继续消费
     */
    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

    consumer.setMessageModel(MessageModel.BROADCASTING);

    consumer.subscribe("TopicTest", "TagA || TagC || TagD");

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);

            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Broadcast Consumer Started.");
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    CommandLine commandLine = buildCommandline(args);
    if (commandLine != null) {
        String group = commandLine.getOptionValue('g');
        String topic = commandLine.getOptionValue('t');
        String subscription = commandLine.getOptionValue('s');
        final String returnFailedHalf = commandLine.getOptionValue('f');

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(group);
        consumer.setInstanceName(Long.toString(System.currentTimeMillis()));

        consumer.subscribe(topic, subscription);

        consumer.registerMessageListener(new MessageListenerConcurrently() {
            AtomicLong consumeTimes = new AtomicLong(0);


            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                    ConsumeConcurrentlyContext context) {
                long currentTimes = this.consumeTimes.incrementAndGet();

                System.out.printf("%-8d %s\n", currentTimes, msgs);

                if (Boolean.parseBoolean(returnFailedHalf)) {
                    if ((currentTimes % 2) == 0) {
                        return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                    }
                }

                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        consumer.start();

        System.out.println("Consumer Started.");
    }
}
 

private RemotingCommand updateConsumerOffset(ChannelHandlerContext ctx, RemotingCommand request)
        throws RemotingCommandException {
    final RemotingCommand response =
            RemotingCommand.createResponseCommand(UpdateConsumerOffsetResponseHeader.class);
    // final UpdateConsumerOffsetResponseHeader responseHeader =
    // (UpdateConsumerOffsetResponseHeader) response.readCustomHeader();
    final UpdateConsumerOffsetRequestHeader requestHeader = (UpdateConsumerOffsetRequestHeader) request
        .decodeCommandCustomHeader(UpdateConsumerOffsetRequestHeader.class);

    // 消息轨迹：记录已经消费成功并提交 offset 的消息记录
    if (this.hasConsumeMessageHook()) {
        // 执行hook
        ConsumeMessageContext context = new ConsumeMessageContext();
        context.setConsumerGroup(requestHeader.getConsumerGroup());
        context.setTopic(requestHeader.getTopic());
        context.setClientHost(RemotingHelper.parseChannelRemoteAddr(ctx.channel()));
        context.setSuccess(true);
        context.setStatus(ConsumeConcurrentlyStatus.CONSUME_SUCCESS.toString());
        final SocketAddress storeHost =
                new InetSocketAddress(brokerController.getBrokerConfig().getBrokerIP1(),
                    brokerController.getNettyServerConfig().getListenPort());

        long preOffset = this.brokerController.getConsumerOffsetManager().queryOffset(
            requestHeader.getConsumerGroup(), requestHeader.getTopic(), requestHeader.getQueueId());
        Map<String, Long> messageIds =
                this.brokerController.getMessageStore().getMessageIds(requestHeader.getTopic(),
                    requestHeader.getQueueId(), preOffset, requestHeader.getCommitOffset(), storeHost);
        context.setMessageIds(messageIds);
        this.executeConsumeMessageHookAfter(context);
    }
    this.brokerController.getConsumerOffsetManager().commitOffset(requestHeader.getConsumerGroup(),
        requestHeader.getTopic(), requestHeader.getQueueId(), requestHeader.getCommitOffset());
    response.setCode(ResponseCode.SUCCESS);
    response.setRemark(null);
    return response;
}
 

@Override
public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
    Object ret) throws Throwable {
    ConsumeConcurrentlyStatus status = (ConsumeConcurrentlyStatus) ret;
    if (status == ConsumeConcurrentlyStatus.RECONSUME_LATER) {
        AbstractSpan activeSpan = ContextManager.activeSpan();
        activeSpan.errorOccurred();
        Tags.STATUS_CODE.set(activeSpan, status.name());
    }
    ContextManager.stopSpan();
    return ret;
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    CommandLine commandLine = buildCommandline(args);
    if (commandLine != null) {
        String group = commandLine.getOptionValue('g');
        String topic = commandLine.getOptionValue('t');
        String subscription = commandLine.getOptionValue('s');
        final String returnFailedHalf = commandLine.getOptionValue('f');

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(group);
        consumer.setInstanceName(Long.toString(System.currentTimeMillis()));

        consumer.subscribe(topic, subscription);

        consumer.registerMessageListener(new MessageListenerConcurrently() {
            AtomicLong consumeTimes = new AtomicLong(0);


            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                            ConsumeConcurrentlyContext context) {
                long currentTimes = this.consumeTimes.incrementAndGet();

                System.out.printf("%-8d %s%n", currentTimes, msgs);

                if (Boolean.parseBoolean(returnFailedHalf)) {
                    if ((currentTimes % 2) == 0) {
                        return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                    }
                }

                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        consumer.start();

        System.out.println("Consumer Started.");
    }
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    CommandLine commandLine = buildCommandline(args);
    if (commandLine != null) {
        String group = commandLine.getOptionValue('g');
        String topic = commandLine.getOptionValue('t');
        String subscription = commandLine.getOptionValue('s');
        final String returnFailedHalf = commandLine.getOptionValue('f');

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(group);
        consumer.setInstanceName(Long.toString(System.currentTimeMillis()));

        consumer.subscribe(topic, subscription);

        consumer.registerMessageListener(new MessageListenerConcurrently() {
            AtomicLong consumeTimes = new AtomicLong(0);


            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                    ConsumeConcurrentlyContext context) {
                long currentTimes = this.consumeTimes.incrementAndGet();

                System.out.printf("%-8d %s\n", currentTimes, msgs);

                if (Boolean.parseBoolean(returnFailedHalf)) {
                    if ((currentTimes % 2) == 0) {
                        return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                    }
                }

                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        consumer.start();

        System.out.println("Consumer Started.");
    }
}
 

@Override
public ConsumeConcurrentlyStatus consumeMessage(String strBody, MessageExt msg,
		ConsumeConcurrentlyContext context)
{
	LOGGER.info("\n 当前线程是" + Thread.currentThread().getId() + "  \n 数据是" + strBody);
	return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
 

private RemotingCommand updateConsumerOffset(ChannelHandlerContext ctx, RemotingCommand request)
        throws RemotingCommandException {
    final RemotingCommand response =
            RemotingCommand.createResponseCommand(UpdateConsumerOffsetResponseHeader.class);
    // final UpdateConsumerOffsetResponseHeader responseHeader =
    // (UpdateConsumerOffsetResponseHeader) response.readCustomHeader();
    final UpdateConsumerOffsetRequestHeader requestHeader =
            (UpdateConsumerOffsetRequestHeader) request
                .decodeCommandCustomHeader(UpdateConsumerOffsetRequestHeader.class);

    if (this.hasConsumeMessageHook()) {
        ConsumeMessageContext context = new ConsumeMessageContext();
        context.setConsumerGroup(requestHeader.getConsumerGroup());
        context.setTopic(requestHeader.getTopic());
        context.setClientHost(RemotingHelper.parseChannelRemoteAddr(ctx.channel()));
        context.setSuccess(true);
        context.setStatus(ConsumeConcurrentlyStatus.CONSUME_SUCCESS.toString());
        final SocketAddress storeHost =
                new InetSocketAddress(brokerController.getBrokerConfig().getBrokerIP1(), brokerController
                    .getNettyServerConfig().getListenPort());

        long preOffset =
                this.brokerController.getConsumerOffsetManager().queryOffset(
                    requestHeader.getConsumerGroup(), requestHeader.getTopic(),
                    requestHeader.getQueueId());
        Map<String, Long> messageIds =
                this.brokerController.getMessageStore().getMessageIds(requestHeader.getTopic(),
                    requestHeader.getQueueId(), preOffset, requestHeader.getCommitOffset(), storeHost);
        context.setMessageIds(messageIds);
        this.executeConsumeMessageHookAfter(context);
    }
    this.brokerController.getConsumerOffsetManager().commitOffset(requestHeader.getConsumerGroup(),
        requestHeader.getTopic(), requestHeader.getQueueId(), requestHeader.getCommitOffset());
    response.setCode(ResponseCode.SUCCESS);
    response.setRemark(null);
    return response;
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("yyzGroup23");
    consumer.setNamesrvAddr("10.2.223.157:9876;10.2.223.158:9876;10.2.223.159:9876");
   // consumer.setNamesrvAddr("10.2.223.228:9876");
    //consumer.subscribe("my-topic-2", "*", new GroovyScript(groovyScript));
    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
    //consumer.setMessageModel(MessageModel.CLUSTERING);
    consumer.subscribe("yyztest2", "*");

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override  //consumeMessage在ConsumeMessageConcurrentlyService中的接口consumeMessageDirectly中執行該函數
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            if(msgs == null || msgs.size() == 0){
                System.out.println("not get msgs"); /* Add Trace Log */
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
            System.out.println("consumeMessage recv {} Msgs:"+msgs.size());
            for (MessageExt msg : msgs) { /* Add Trace Log */
                System.out.println("Msgid:{}" +msg.getMsgId());
            }

            for(MessageExt messageExt: msgs) {
                System.out.println("recv msg with topic:" + messageExt.getTopic() + ",msgTag:" + messageExt.getTags() +  ", body:" + new String(messageExt.getBody()));
            }
             /* 如果返回不是成功，则该msgs消息会在内存中，offset还是在上次的位置 */
            //业务处理消息后，对返回值的检查在ConsumeRequest.run-> ConsumeMessageConcurrentlyService.processConsumeResult 中
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Consumer Started.");
}
 

@Test
public void producerConsumerTest() throws MQClientException, InterruptedException {
    System.setProperty("rocketmq.namesrv.domain", "jmenv.tbsite.alipay.net");

    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("S_fundmng_demo_producer");
    DefaultMQProducer producer = new DefaultMQProducer("P_fundmng_demo_producer");

    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
    consumer.subscribe(TOPIC_TEST, null);

    final AtomicLong lastReceivedMills = new AtomicLong(System.currentTimeMillis());

    final AtomicLong consumeTimes = new AtomicLong(0);

    consumer.registerMessageListener(new MessageListenerConcurrently() {
        public ConsumeConcurrentlyStatus consumeMessage(final List<MessageExt> msgs,
                final ConsumeConcurrentlyContext context) {
            System.out.println("Received" + consumeTimes.incrementAndGet() + "messages !");

            lastReceivedMills.set(System.currentTimeMillis());

            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();
    producer.start();

    for (int i = 0; i < 100; i++) {
        try {
            Message msg = new Message(TOPIC_TEST, ("Hello RocketMQ " + i).getBytes());
            SendResult sendResult = producer.send(msg);
            System.out.println(sendResult);
        }
        catch (Exception e) {
            TimeUnit.SECONDS.sleep(1);
        }
    }

    // wait no messages
    while ((System.currentTimeMillis() - lastReceivedMills.get()) < 5000) {
        TimeUnit.MILLISECONDS.sleep(200);
    }

    consumer.shutdown();
    producer.shutdown();
}
 

@Override
public ConsumeMessageDirectlyResult consumeMessageDirectly(MessageExt msg, String brokerName) {
    ConsumeMessageDirectlyResult result = new ConsumeMessageDirectlyResult();
    result.setOrder(false);
    result.setAutoCommit(true);

    List<MessageExt> msgs = new ArrayList<MessageExt>();
    msgs.add(msg);
    MessageQueue mq = new MessageQueue();
    mq.setBrokerName(brokerName);
    mq.setTopic(msg.getTopic());
    mq.setQueueId(msg.getQueueId());

    ConsumeConcurrentlyContext context = new ConsumeConcurrentlyContext(mq);

    this.resetRetryTopic(msgs);

    final long beginTime = System.currentTimeMillis();

    log.info("consumeMessageDirectly receive new messge: {}", msg);

    try {
        ConsumeConcurrentlyStatus status = this.messageListener.consumeMessage(msgs, context);
        if (status != null) {
            switch (status) {
            case CONSUME_SUCCESS:
                result.setConsumeResult(CMResult.CR_SUCCESS);
                break;
            case RECONSUME_LATER:
                result.setConsumeResult(CMResult.CR_LATER);
                break;
            default:
                break;
            }
        }
        else {
            result.setConsumeResult(CMResult.CR_RETURN_NULL);
        }
    }
    catch (Throwable e) {
        result.setConsumeResult(CMResult.CR_THROW_EXCEPTION);
        result.setRemark(RemotingHelper.exceptionSimpleDesc(e));

        log.warn(String.format("consumeMessageDirectly exception: %s Group: %s Msgs: %s MQ: %s",//
            RemotingHelper.exceptionSimpleDesc(e),//
            ConsumeMessageConcurrentlyService.this.consumerGroup,//
            msgs,//
            mq), e);
    }

    result.setSpentTimeMills(System.currentTimeMillis() - beginTime);

    log.info("consumeMessageDirectly Result: {}", result);

    return result;
}
 

@Test
public void producerConsumerTest() throws MQClientException, InterruptedException {
    System.setProperty("rocketmq.namesrv.domain", "jmenv.tbsite.alipay.net");

    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("S_fundmng_demo_producer");
    DefaultMQProducer producer = new DefaultMQProducer("P_fundmng_demo_producer");

    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
    consumer.subscribe(TOPIC_TEST, null);

    final AtomicLong lastReceivedMills = new AtomicLong(System.currentTimeMillis());

    final AtomicLong consumeTimes = new AtomicLong(0);

    consumer.registerMessageListener(new MessageListenerConcurrently() {
        public ConsumeConcurrentlyStatus consumeMessage(final List<MessageExt> msgs,
                                                        final ConsumeConcurrentlyContext context) {
            System.out.println("Received" + consumeTimes.incrementAndGet() + "messages !");

            lastReceivedMills.set(System.currentTimeMillis());

            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();
    producer.start();

    for (int i = 0; i < 100; i++) {
        try {
            Message msg = new Message(TOPIC_TEST, ("Hello RocketMQ " + i).getBytes());
            SendResult sendResult = producer.send(msg);
            System.out.println(sendResult);
        } catch (Exception e) {
            TimeUnit.SECONDS.sleep(1);
        }
    }

    // wait no messages
    while ((System.currentTimeMillis() - lastReceivedMills.get()) < 5000) {
        TimeUnit.MILLISECONDS.sleep(200);
    }

    consumer.shutdown();
    producer.shutdown();
}
 

public static void main(String[] args) throws InterruptedException, MQClientException {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_1");

    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

    consumer.setMessageModel(MessageModel.BROADCASTING);

    consumer.subscribe("TopicTest", "TagA || TagC || TagD");

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);

            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Broadcast Consumer Started.");
}
 

public static void main(String[] args) throws MQClientException {
    final StatsBenchmarkConsumer statsBenchmarkConsumer = new StatsBenchmarkConsumer();

    final Timer timer = new Timer("BenchmarkTimerThread", true);

    final LinkedList<Long[]> snapshotList = new LinkedList<Long[]>();

    timer.scheduleAtFixedRate(new TimerTask() {
        @Override
        public void run() {
            snapshotList.addLast(statsBenchmarkConsumer.createSnapshot());
            if (snapshotList.size() > 10) {
                snapshotList.removeFirst();
            }
        }
    }, 1000, 1000);

    timer.scheduleAtFixedRate(new TimerTask() {
        private void printStats() {
            if (snapshotList.size() >= 10) {
                Long[] begin = snapshotList.getFirst();
                Long[] end = snapshotList.getLast();

                final long consumeTps =
                        (long) (((end[1] - begin[1]) / (double) (end[0] - begin[0])) * 1000L);
                final double averageB2CRT = ((end[2] - begin[2]) / (double) (end[1] - begin[1]));
                final double averageS2CRT = ((end[3] - begin[3]) / (double) (end[1] - begin[1]));

                System.out.printf(
                    "Consume TPS: %d Average(B2C) RT: %7.3f Average(S2C) RT: %7.3f MAX(B2C) RT: %d MAX(S2C) RT: %d\n"//
                    , consumeTps//
                    , averageB2CRT//
                    , averageS2CRT//
                    , end[4]//
                    , end[5]//
                    );
            }
        }


        @Override
        public void run() {
            try {
                this.printStats();
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }, 10000, 10000);

    DefaultMQPushConsumer consumer =
            new DefaultMQPushConsumer("benchmark_consumer_"
                    + Long.toString(System.currentTimeMillis() % 100));
    consumer.setInstanceName(Long.toString(System.currentTimeMillis()));

    consumer.subscribe("BenchmarkTest", "*");

    consumer.registerMessageListener(new MessageListenerConcurrently() {
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            MessageExt msg = msgs.get(0);
            long now = System.currentTimeMillis();

            // 1
            statsBenchmarkConsumer.getReceiveMessageTotalCount().incrementAndGet();

            // 2
            long born2ConsumerRT = now - msg.getBornTimestamp();
            statsBenchmarkConsumer.getBorn2ConsumerTotalRT().addAndGet(born2ConsumerRT);

            // 3
            long store2ConsumerRT = now - msg.getStoreTimestamp();
            statsBenchmarkConsumer.getStore2ConsumerTotalRT().addAndGet(store2ConsumerRT);

            // 4
            compareAndSetMax(statsBenchmarkConsumer.getBorn2ConsumerMaxRT(), born2ConsumerRT);

            // 5
            compareAndSetMax(statsBenchmarkConsumer.getStore2ConsumerMaxRT(), store2ConsumerRT);

            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    consumer.start();

    System.out.println("Consumer Started.");
}
 

/**
 * 当前例子是PushConsumer用法，使用方式给用户感觉是消息从RocketMQ服务器推到了应用客户端。<br>
 * 但是实际PushConsumer内部是使用长轮询Pull方式从Broker拉消息，然后再回调用户Listener方法<br>
 */
public static void main(String[] args) throws InterruptedException, MQClientException {
    /**
     * 一个应用创建一个Consumer，由应用来维护此对象，可以设置为全局对象或者单例<br>
     * 注意：ConsumerGroupName需要由应用来保证唯一
     */
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("CID_001");

    /**
     * 订阅指定topic下tags分别等于TagA或TagC或TagD
     */
    consumer.subscribe("TopicTest1", "TagA || TagC || TagD");
    /**
     * 订阅指定topic下所有消息<br>
     * 注意：一个consumer对象可以订阅多个topic
     */
    consumer.subscribe("TopicTest2", "*");
    consumer.subscribe("TopicTest3", "*");

    /**
     * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
     * 如果非第一次启动，那么按照上次消费的位置继续消费
     */
    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        /**
         * 默认msgs里只有一条消息，可以通过设置consumeMessageBatchMaxSize参数来批量接收消息
         */
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);

            MessageExt msg = msgs.get(0);
            if (msg.getTopic().equals("TopicTest1")) {
                // 执行TopicTest1的消费逻辑
                if (msg.getTags() != null && msg.getTags().equals("TagA")) {
                    // 执行TagA的消费
                }
                else if (msg.getTags() != null && msg.getTags().equals("TagC")) {
                    // 执行TagC的消费
                }
                else if (msg.getTags() != null && msg.getTags().equals("TagD")) {
                    // 执行TagD的消费
                }
            }
            else if (msg.getTopic().equals("TopicTest2")) {
                // 执行TopicTest2的消费逻辑
            }

            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });

    /**
     * Consumer对象在使用之前必须要调用start初始化，初始化一次即可<br>
     */
    consumer.start();

    System.out.println("Consumer Started.");
}