RocketMQ-API

0.依赖

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>5.1.0</version>
</dependency>

1.生产者

1.1 同步发送

等待消息返回再继续
重要的消息通知，短信通知。

public class SyncProducer {
    public static void main(String[] args) throws Exception {
        // 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("lwxProducer");
        // 设置NameServer的地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动Producer实例
        producer.start();
        for (int i = 0; i < 2; i++) {
            // 创建消息，并指定Topic，Tag和消息体
            Message msg = new Message("TopicTest" /* Topic */,
                    "TagA" /* Tag */,
                    ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
            );
            // 发送消息到一个Broker
            SendResult sendResult = producer.send(msg);
            // 通过sendResult返回消息是否成功送达
            System.out.printf("%s%n", sendResult);
        }
        // 如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }
}

1.2 异步发送

不等待消息返回直接进入后续流程。broker将结果返回后调用callback函数, 并使用CountDownLatch计数。
发送端不能容忍长时间地等待Broker的响应

public class AsyncProducer {
    public static void main(String[] args) throws Exception {
        // 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("lwxProducer");
        // 设置NameServer的地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动Producer实例
        producer.start();
        producer.setRetryTimesWhenSendAsyncFailed(0);

        int messageCount = 5;
        // 根据消息数量实例化倒计时计算器
        final CountDownLatch2 countDownLatch = new CountDownLatch2(messageCount);
        for (int i = 0; i < messageCount; i++) {
            final int index = i;
            // 创建消息，并指定Topic，Tag和消息体
            Message msg = new Message("TopicTest",
                    "TagA",
                    "OrderID188",
                    "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
            // SendCallback接收异步返回结果的回调
            producer.send(msg, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    countDownLatch.countDown();
                    System.out.printf("%-10d C %s %n", index,
                            sendResult.getMsgId());
                }
                @Override
                public void onException(Throwable e) {
                    countDownLatch.countDown();
                    System.out.printf("%-10d Exception %s %n", index, e);
                    e.printStackTrace();
                }
            });
        }
        // 等待5s
        countDownLatch.await(5, TimeUnit.SECONDS);
        // 如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }
}

1.3 单向发送

只负责发送，不管消息是否发送成功。日志发送。

public class OnewayProducer {
    public static void main(String[] args) throws Exception{
        // 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("producerGroup");
        // 设置NameServer的地址
        producer.setNamesrvAddr("localhost:9876");
        // 启动Producer实例
        producer.start();
        for (int i = 0; i < 100; i++) {
            // 创建消息，并指定Topic，Tag和消息体
            Message msg = new Message("TopicTest" /* Topic */,
                    "TagA" /* Tag */,
                    ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
            );
            // 发送单向消息，没有任何返回结果
            producer.sendOneway(msg);

        }
        // 如果不再发送消息，关闭Producer实例。
        producer.shutdown();
    }
}

2.消费者

2.1 拉模式

消费者主动去Broker上拉取消息。

public class Consumer {

    public static void main(String[] args) throws InterruptedException, MQClientException {
        // 实例化消费者
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("lwxConsumer");
        // 设置NameServer的地址
        consumer.setNamesrvAddr("127.0.0.1:9876");
        // 订阅一个或者多个Topic，以及Tag来过滤需要消费的消息
        consumer.subscribe("TopicTest", "*");
        // 注册回调实现类来处理从broker拉取回来的消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//                System.out.println("lwx123");
//                System.out.printf("%s Receive New Messages: %s %n", Thread.currentThread().getName(), msgs);
                for (MessageExt msg : msgs) {
                    System.out.println(new String(msg.getBody()));
                }
                // 标记该消息已经被成功消费
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 启动消费者实例
        consumer.start();
        System.out.printf("Consumer Started.%n");
    }
}

2.2 推模式

消费者等待Broker把消息推送过来。

public class PullConsumer {

    public static void main(String[] args) {
        fun();
    }

    /**
     * 随机queue获取消息
     */
    public static void fun1(){
        try {
            DefaultLitePullConsumer consumer = new DefaultLitePullConsumer("pullConsumer");
            consumer.setNamesrvAddr("127.0.0.1:9876");
            consumer.subscribe("TopicTest", "*");
            consumer.start();
            while(true){
                List<MessageExt> messages = consumer.poll();
                for (MessageExt msg : messages) {
                    System.out.println(new String(msg.getBody()));
                }
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 指定queue方式
     */
    public static void fun(){
        try {
            DefaultLitePullConsumer consumer = new DefaultLitePullConsumer("pullConsumer");
            consumer.setNamesrvAddr("127.0.0.1:9876");
            consumer.start();
            Collection<MessageQueue> messageQueues = consumer.fetchMessageQueues("TopicTest");
            ArrayList<MessageQueue> messageQueues1 = new ArrayList<>(messageQueues);
            consumer.assign(messageQueues1);
            consumer.seek(messageQueues1.get(0), 1);
            while(true){
                List<MessageExt> messages = consumer.poll();
                for (MessageExt msg : messages) {
                    System.out.println(msg);
                    System.out.println(new String(msg.getBody()));
                }
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}