黑马程序员rocketmq第一章

已于 2022-10-02 12:51:51 修改
阅读量581 收藏
点赞数
分类专栏： 黑马程序员rocketmq 文章标签： rocketmq
于 2022-09-24 19:57:10 首次发布
本文为博主原创文章，未经博主允许不得转载
本文链接：https://blog.csdn.net/qq_46198929/article/details/126911995
版权
1）发送同步消息
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;

import java.util.concurrent.TimeUnit;

/**
 * 发送同步消息
 */
public class SyncProducer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.129:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag1", ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.send(msg);
            //发送状态
            SendStatus status = result.getSendStatus();

            System.out.println("发送结果:" + result);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(1);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }
}


发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC2574563DB0000, offsetMsgId=C0A8568100002A9F0000000000057D64, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=3], queueOffset=0]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC2574567E80001, offsetMsgId=C0A8568100002A9F0000000000057E0D, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=0], queueOffset=0]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC257456BDB0002, offsetMsgId=C0A8568100002A9F0000000000057EB6, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=1], queueOffset=0]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC257456FC90003, offsetMsgId=C0A8568100002A9F0000000000057F5F, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=2], queueOffset=0]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC2574573B80004, offsetMsgId=C0A8568100002A9F0000000000058008, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=3], queueOffset=1]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC2574577A90005, offsetMsgId=C0A8568100002A9F00000000000580B1, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=0], queueOffset=1]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC257457B9C0006, offsetMsgId=C0A8568100002A9F000000000005815A, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=1], queueOffset=1]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC257457F890007, offsetMsgId=C0A8568100002A9F0000000000058203, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=2], queueOffset=1]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC2574583810008, offsetMsgId=C0A8568100002A9F00000000000582AC, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=3], queueOffset=2]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80108546C18B4AAC2574587770009, offsetMsgId=C0A8568100002A9F0000000000058355, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=0], queueOffset=2]

Process finished with exit code 0
2）发送异步消息
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.common.message.Message;

import java.util.concurrent.TimeUnit;

/**
 * 发送异步消息
 */
public class AsyncProducer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.129:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag2", ("Hello World" + i).getBytes());
            //5.发送异步消息
            producer.send(msg, new SendCallback() {
                /**
                 * 发送成功回调函数
                 * @param sendResult
                 */
                public void onSuccess(SendResult sendResult) {
                    System.out.println("发送结果：" + sendResult);
                }

                /**
                 * 发送失败回调函数
                 * @param e
                 */
                public void onException(Throwable e) {
                    System.out.println("发送异常：" + e);
                }
            });

            //线程睡1秒
            TimeUnit.SECONDS.sleep(1);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }
}


发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DD1090000, offsetMsgId=C0A8568100002A9F000000000005884E, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=3], queueOffset=4]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DD4060001, offsetMsgId=C0A8568100002A9F00000000000588F7, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=3], queueOffset=5]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DD7F70002, offsetMsgId=C0A8568100002A9F00000000000589A0, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=0], queueOffset=5]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DDBEE0003, offsetMsgId=C0A8568100002A9F0000000000058A49, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=0], queueOffset=6]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DDFDD0004, offsetMsgId=C0A8568100002A9F0000000000058AF2, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=1], queueOffset=4]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DE3D10005, offsetMsgId=C0A8568100002A9F0000000000058B9B, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=3], queueOffset=6]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DE7BF0006, offsetMsgId=C0A8568100002A9F0000000000058C44, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=3], queueOffset=7]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DEBA80007, offsetMsgId=C0A8568100002A9F0000000000058CED, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=1], queueOffset=5]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DEF930008, offsetMsgId=C0A8568100002A9F0000000000058D96, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=3], queueOffset=8]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A80108089018B4AAC2574DF3800009, offsetMsgId=C0A8568100002A9F0000000000058E3F, messageQueue=MessageQueue [topic=base, brokerName=java, queueId=1], queueOffset=6]
3）单向发送消息
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;

import java.util.concurrent.TimeUnit;

/**
 * 发送单向消息
 */
public class OneWayProducer {

    public static void main(String[] args) throws Exception, MQBrokerException {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.129:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 3; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("base", "Tag3", ("Hello World，单向消息" + i).getBytes());
            //5.发送单向消息
            producer.sendOneway(msg);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(5);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }
}
4）消费消息基本流程
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.message.MessageExt;

import java.util.List;

/**
 * 消息的接受者
 */
public class Consumer {

    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.86.129:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("base", "Tag1");

        //设定消费模式：负载均衡|广播模式
        //consumer.setMessageModel(MessageModel.BROADCASTING);

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接受消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
    }
}


consumeThread=ConsumeMessageThread_1,Hello World0
consumeThread=ConsumeMessageThread_2,Hello World1
consumeThread=ConsumeMessageThread_3,Hello World2
consumeThread=ConsumeMessageThread_4,Hello World3
consumeThread=ConsumeMessageThread_5,Hello World4
consumeThread=ConsumeMessageThread_6,Hello World5
consumeThread=ConsumeMessageThread_7,Hello World6
consumeThread=ConsumeMessageThread_8,Hello World7
consumeThread=ConsumeMessageThread_9,Hello World8
consumeThread=ConsumeMessageThread_10,Hello World9

5 消费消息

1）负载均衡模式

消费者采用负载均衡方式消费消息，多个消费者共同消费队列消息，每个消费者处理的消息不同

public static void main(String[] args) throws Exception {
    // 实例化消息生产者,指定组名
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
    // 指定Namesrv地址信息.
    consumer.setNamesrvAddr("localhost:9876");
    // 订阅Topic
    consumer.subscribe("Test", "*");
    //负载均衡模式消费
    consumer.setMessageModel(MessageModel.CLUSTERING);
    // 注册回调函数，处理消息
    consumer.registerMessageListener(new MessageListenerConcurrently() {
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                        ConsumeConcurrentlyContext context) {
            System.out.printf("%s Receive New Messages: %s %n", 
                              Thread.currentThread().getName(), msgs);
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });
    //启动消息者
    consumer.start();
    System.out.printf("Consumer Started.%n");
}
2）广播模式

消费者采用广播的方式消费消息，每个消费者消费的消息都是相同的

public static void main(String[] args) throws Exception {
    // 实例化消息生产者,指定组名
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
    // 指定Namesrv地址信息.
    consumer.setNamesrvAddr("localhost:9876");
    // 订阅Topic
    consumer.subscribe("Test", "*");
    //广播模式消费
    consumer.setMessageModel(MessageModel.BROADCASTING);
    // 注册回调函数，处理消息
    consumer.registerMessageListener(new MessageListenerConcurrently() {
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                        ConsumeConcurrentlyContext context) {
            System.out.printf("%s Receive New Messages: %s %n", 
                              Thread.currentThread().getName(), msgs);
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });
    //启动消息者
    consumer.start();
    System.out.printf("Consumer Started.%n");
}
顺序消息发送者

/**
* 订单的步骤
*/

import java.util.ArrayList;
import java.util.List;

/**
 * 订单构建者
 */
public class OrderStep {
    private long orderId;
    private String desc;

    public long getOrderId() {
        return orderId;
    }

    public void setOrderId(long orderId) {
        this.orderId = orderId;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "OrderStep{" +
                "orderId=" + orderId +
                ", desc='" + desc + '\'' +
                '}';
    }

    public static List<OrderStep> buildOrders() {
        //  1039L   : 创建    付款 推送 完成
        //  1065L   ： 创建   付款
        //  7235L   ：创建    付款
        List<OrderStep> orderList = new ArrayList<OrderStep>();

        OrderStep orderDemo = new OrderStep();
        orderDemo.setOrderId(1039L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1065L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1039L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(7235L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1065L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(7235L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1065L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1039L);
        orderDemo.setDesc("推送");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(7235L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(1039L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        return orderList;
    }
}


import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;

import java.util.List;

public class Producer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.132:9876");

        //3.启动producer
        producer.start();
        //producer.setVipChannelEnabled(false);
        //构建消息集合
        List<OrderStep> orderSteps = OrderStep.buildOrders();
        //发送消息
        for (int i = 0; i < orderSteps.size(); i++) {
            String body = orderSteps.get(i) + "";
            Message message = new Message("OrderTopic", "Order", "i" + i, body.getBytes());
            /**
             * 参数一：消息对象
             * 参数二：消息队列的选择器
             * 参数三：选择队列的业务标识（订单ID）
             */
            SendResult sendResult = producer.send(message, new MessageQueueSelector() {
                /**
                 *
                 * @param mqs：队列集合
                 * @param msg：消息对象
                 * @param arg：业务标识的参数
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    long orderId = (long) arg;
                    long index = orderId % mqs.size();
                    return mqs.get((int) index);
                }
            }, orderSteps.get(i).getOrderId());

            System.out.println("发送结果：" + sendResult);
        }
        producer.shutdown();
    }

}


import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;

public class Consumer {
    public static void main(String[] args) throws MQClientException {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.86.132:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("OrderTopic", "*");

        //4.注册消息监听器
        consumer.registerMessageListener(new MessageListenerOrderly() {

            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("线程名称：【" + Thread.currentThread().getName() + "】:" + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });

        //5.启动消费者
        consumer.start();

        System.out.println("消费者启动");

    }
}


发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAE70000, offsetMsgId=C0A8568400002A9F000000000005CAAE, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=3], queueOffset=21]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAEE0001, offsetMsgId=C0A8568400002A9F000000000005CB80, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=1], queueOffset=9]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAF00002, offsetMsgId=C0A8568400002A9F000000000005CC52, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=3], queueOffset=22]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAF30003, offsetMsgId=C0A8568400002A9F000000000005CD24, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=3], queueOffset=23]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAF50004, offsetMsgId=C0A8568400002A9F000000000005CDF6, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=1], queueOffset=10]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAF60005, offsetMsgId=C0A8568400002A9F000000000005CEC8, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=3], queueOffset=24]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAF80006, offsetMsgId=C0A8568400002A9F000000000005CF9A, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=1], queueOffset=11]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAF90007, offsetMsgId=C0A8568400002A9F000000000005D06C, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=3], queueOffset=25]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAFB0008, offsetMsgId=C0A8568400002A9F000000000005D13E, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=3], queueOffset=26]
发送结果：SendResult [sendStatus=SEND_OK, msgId=C0A801066C6418B4AAC2031EBAFF0009, offsetMsgId=C0A8568400002A9F000000000005D210, messageQueue=MessageQueue [topic=OrderTopic, brokerName=java, queueId=3], queueOffset=27]

Process finished with exit code 0


消费者启动
线程名称：【ConsumeMessageThread_1】:OrderStep{orderId=1065, desc='创建'}
线程名称：【ConsumeMessageThread_2】:OrderStep{orderId=1039, desc='创建'}
线程名称：【ConsumeMessageThread_1】:OrderStep{orderId=1065, desc='付款'}
线程名称：【ConsumeMessageThread_2】:OrderStep{orderId=1039, desc='付款'}
线程名称：【ConsumeMessageThread_1】:OrderStep{orderId=1065, desc='完成'}
线程名称：【ConsumeMessageThread_2】:OrderStep{orderId=7235, desc='创建'}
线程名称：【ConsumeMessageThread_2】:OrderStep{orderId=7235, desc='付款'}
线程名称：【ConsumeMessageThread_2】:OrderStep{orderId=1039, desc='推送'}
线程名称：【ConsumeMessageThread_2】:OrderStep{orderId=7235, desc='完成'}
线程名称：【ConsumeMessageThread_2】:OrderStep{orderId=1039, desc='完成'}
延迟消息
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
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 java.util.concurrent.TimeUnit;

public class Producer {

    public static void main(String[] args) throws InterruptedException, RemotingException, MQClientException, MQBrokerException {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.132:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("DelayTopic", "Tag1", ("Hello World" + i).getBytes());
            //设定延迟时间
            msg.setDelayTimeLevel(2);
            //5.发送消息
            SendResult result = producer.send(msg);
            //发送状态
            SendStatus status = result.getSendStatus();

            System.out.println("发送结果:" + result);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(1);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }

}


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.message.MessageExt;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.86.132:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("DelayTopic", "*");

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接受消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("消息ID：【" + msg.getMsgId() + "】,延迟时间：" + (System.currentTimeMillis() - msg.getStoreTimestamp()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();

        System.out.println("消费者启动");
    }
}


发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E5CA20000, offsetMsgId=C0A8568400002A9F000000000005D2E2, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=3], queueOffset=0]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E609C0001, offsetMsgId=C0A8568400002A9F000000000005D3C3, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=0], queueOffset=1]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E648E0002, offsetMsgId=C0A8568400002A9F000000000005D4A4, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=1], queueOffset=2]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E68840003, offsetMsgId=C0A8568400002A9F000000000005D585, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=2], queueOffset=3]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E6C770004, offsetMsgId=C0A8568400002A9F000000000005D666, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=3], queueOffset=4]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E706E0005, offsetMsgId=C0A8568400002A9F000000000005D81F, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=0], queueOffset=5]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E74640006, offsetMsgId=C0A8568400002A9F000000000005D9D8, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=1], queueOffset=6]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E78580007, offsetMsgId=C0A8568400002A9F000000000005DB91, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=2], queueOffset=7]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E7C440008, offsetMsgId=C0A8568400002A9F000000000005DD4A, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=3], queueOffset=8]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106691418B4AAC2032E80330009, offsetMsgId=C0A8568400002A9F000000000005DF03, messageQueue=MessageQueue [topic=DelayTopic, brokerName=java, queueId=0], queueOffset=9]

Process finished with exit code 0


消费者启动
消息ID：【C0A80106691418B4AAC2032E68840003】,延迟时间：21647
消息ID：【C0A80106691418B4AAC2032E78580007】,延迟时间：17595
消息ID：【C0A80106691418B4AAC2032E609C0001】,延迟时间：26608
消息ID：【C0A80106691418B4AAC2032E706E0005】,延迟时间：22557
消息ID：【C0A80106691418B4AAC2032E648E0002】,延迟时间：25599
消息ID：【C0A80106691418B4AAC2032E5CA20000】,延迟时间：27618
消息ID：【C0A80106691418B4AAC2032E80330009】,延迟时间：18522
消息ID：【C0A80106691418B4AAC2032E6C770004】,延迟时间：23574
消息ID：【C0A80106691418B4AAC2032E74640006】,延迟时间：21546
消息ID：【C0A80106691418B4AAC2032E7C440008】,延迟时间：19529
批量消息发送
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Producer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.132:9876");
        //3.启动producer
        producer.start();


        List<Message> msgs = new ArrayList<Message>();


        //4.创建消息对象，指定主题Topic、Tag和消息体
        /**
         * 参数一：消息主题Topic
         * 参数二：消息Tag
         * 参数三：消息内容
         */
        Message msg1 = new Message("BatchTopic", "Tag1", ("Hello World" + 1).getBytes());
        Message msg2 = new Message("BatchTopic", "Tag1", ("Hello World" + 2).getBytes());
        Message msg3 = new Message("BatchTopic", "Tag1", ("Hello World" + 3).getBytes());

        msgs.add(msg1);
        msgs.add(msg2);
        msgs.add(msg3);

        //5.发送消息
        SendResult result = producer.send(msgs);
        //发送状态
        SendStatus status = result.getSendStatus();

        System.out.println("发送结果:" + result);

        //线程睡1秒
        TimeUnit.SECONDS.sleep(1);


        //6.关闭生产者producer
        producer.shutdown();
    }

}


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.message.MessageExt;

import java.util.List;

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.86.132:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("BatchTopic", "*");

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接受消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();

        System.out.println("消费者启动");
    }
}



发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A8010647B418B4AAC2033C13190000,C0A8010647B418B4AAC2033C13190001,C0A8010647B418B4AAC2033C13190002, offsetMsgId=C0A8568400002A9F000000000005E41C,C0A8568400002A9F000000000005E4CB,C0A8568400002A9F000000000005E57A, messageQueue=MessageQueue [topic=BatchTopic, brokerName=java, queueId=3], queueOffset=0]

Process finished with exit code 0


消费者启动
consumeThread=ConsumeMessageThread_3,Hello World3
consumeThread=ConsumeMessageThread_2,Hello World2
consumeThread=ConsumeMessageThread_1,Hello World1
过滤消息的两种方式
Tag过滤
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;

import java.util.concurrent.TimeUnit;

public class Producer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.132:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 3; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("FilterTagTopic", "Tag2", ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.send(msg);
            //发送状态
            SendStatus status = result.getSendStatus();

            System.out.println("发送结果:" + result);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(1);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }

}


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.message.MessageExt;

import java.util.List;

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.86.132:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("FilterTagTopic", "Tag1 || Tag2 ");

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接受消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
        System.out.println("消费者启动");
    }
}


发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106695818B4AAC2037F28920000, offsetMsgId=C0A8568400002A9F000000000005E629, messageQueue=MessageQueue [topic=FilterTagTopic, brokerName=java, queueId=2], queueOffset=0]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106695818B4AAC2037F2C8A0001, offsetMsgId=C0A8568400002A9F000000000005E6DC, messageQueue=MessageQueue [topic=FilterTagTopic, brokerName=java, queueId=3], queueOffset=0]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106695818B4AAC2037F307D0002, offsetMsgId=C0A8568400002A9F000000000005E78F, messageQueue=MessageQueue [topic=FilterTagTopic, brokerName=java, queueId=0], queueOffset=0]

消费者启动
consumeThread=ConsumeMessageThread_1,Hello World2
consumeThread=ConsumeMessageThread_2,Hello World1
consumeThread=ConsumeMessageThread_3,Hello World0
SQL语法过滤
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.common.message.Message;

import java.util.concurrent.TimeUnit;

public class Producer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.132:9876");
        //3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("FilterSQLTopic", "Tag1", ("Hello World" + i).getBytes());

            msg.putUserProperty("i", String.valueOf(i));

            //5.发送消息
            SendResult result = producer.send(msg);
            //发送状态
            SendStatus status = result.getSendStatus();

            System.out.println("发送结果:" + result);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(2);
        }

        //6.关闭生产者producer
        producer.shutdown();
    }

}


import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.MessageSelector;
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.message.MessageExt;

import java.util.List;

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.86.132:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("FilterSQLTopic", MessageSelector.bySql("i>5"));

        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接受消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
        System.out.println("消费者启动");
    }
}
事务消息的实现
import org.apache.commons.lang3.StringUtils;
import org.apache.rocketmq.client.producer.*;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.concurrent.TimeUnit;

/**
 * 发送同步消息
 */
public class Producer {

    public static void main(String[] args) throws Exception {
        //1.创建消息生产者producer，并制定生产者组名
        TransactionMQProducer producer = new TransactionMQProducer("group5");
        //2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.86.132:9876");

        //添加事务监听器
        producer.setTransactionListener(new TransactionListener() {
            /**
             * 在该方法中执行本地事务
             * @param msg
             * @param arg
             * @return
             */
            @Override
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
                if (StringUtils.equals("TAGA", msg.getTags())) {
                    return LocalTransactionState.COMMIT_MESSAGE;
                } else if (StringUtils.equals("TAGB", msg.getTags())) {
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                } else if (StringUtils.equals("TAGC", msg.getTags())) {
                    return LocalTransactionState.UNKNOW;
                }
                return LocalTransactionState.UNKNOW;
            }

            /**
             * 该方法时MQ进行消息事务状态回查
             * @param msg
             * @return
             */
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
                System.out.println("消息的Tag:" + msg.getTags());
                return LocalTransactionState.COMMIT_MESSAGE;
            }
        });

        //3.启动producer
        producer.start();

        String[] tags = {"TAGA", "TAGB", "TAGC"};

        for (int i = 0; i < 3; i++) {
            //4.创建消息对象，指定主题Topic、Tag和消息体
            /**
             * 参数一：消息主题Topic
             * 参数二：消息Tag
             * 参数三：消息内容
             */
            Message msg = new Message("TransactionTopic", tags[i], ("Hello World" + i).getBytes());
            //5.发送消息
            SendResult result = producer.sendMessageInTransaction(msg, null);
            //发送状态
            SendStatus status = result.getSendStatus();

            System.out.println("发送结果:" + result);

            //线程睡1秒
            TimeUnit.SECONDS.sleep(2);
        }

        //6.关闭生产者producer
        //producer.shutdown();
    }
}


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.message.MessageExt;

import java.util.List;

/**
 * 消息的接受者
 */
public class Consumer {

    public static void main(String[] args) throws Exception {
        //1.创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.86.132:9876");
        //3.订阅主题Topic和Tag
        consumer.subscribe("TransactionTopic", "*");


        //4.设置回调函数，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            //接受消息内容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                for (MessageExt msg : msgs) {
                    System.out.println("consumeThread=" + Thread.currentThread().getName() + "," + new String(msg.getBody()));
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.启动消费者consumer
        consumer.start();
        System.out.println("生产者启动");
    }
}


发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106651818B4AAC203A813A50000, offsetMsgId=null, messageQueue=MessageQueue [topic=TransactionTopic, brokerName=java, queueId=1], queueOffset=0]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106651818B4AAC203A81B880001, offsetMsgId=null, messageQueue=MessageQueue [topic=TransactionTopic, brokerName=java, queueId=2], queueOffset=1]
发送结果:SendResult [sendStatus=SEND_OK, msgId=C0A80106651818B4AAC203A8235C0002, offsetMsgId=null, messageQueue=MessageQueue [topic=TransactionTopic, brokerName=java, queueId=3], queueOffset=2]
消息的Tag:TAGC

生产者启动
consumeThread=ConsumeMessageThread_1,Hello World2
consumeThread=ConsumeMessageThread_2,Hello World0
漫漫人生路^_^
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RocketMQ学习笔记三（黑马）大神级
2301_81298401的博客
03-13 600
（时长：19.5h）讲解版本：4.5版本（我是以4.8版本实践的）
RocketMQ学习 专题总结(一)
taylor的博客
09-23 1247
RocketMQ 专题RocketMQ 专题一1. MQ介绍1.2 MQ的优点和缺点1.3 各种MQ产品的比较2. RocketMQ快速入门2.1 准备工作2.1.1 下载RocketMQ2.2.2 环境要求2.2 安装RocketMQ2.2.1 安装步骤2.2.2 目录介绍2.3 启动RocketMQ2.4 测试RocketMQ2.4.1 发送消息2.4.2 接收消息2.5 关闭RocketMQ...
RocketMQ 第二章 项目实战 4 下单业务 4.2 失败补偿机制
谢谢你们的关注
12-31 765
RocketMQ 第二章 项目实战 4 下单业务 4.2 失败补偿机制
RocketMQ 第三章 高级功能和源码分析 2 源码分析 2.2 NameServer 2.2.1 架构设计 & 2.2.2 启动流程
谢谢你们的关注
01-01 191
RocketMQ 第三章 高级功能和源码分析 2 源码分析 2.2 NameServer 2.2.1 架构设计 & 2.2.2 启动流程
RocketMQ源码环境搭建
公号：一条coding
07-29 1748
RocketMQ源码环境搭建
RocketMQ 第二章 项目实战 3 环境搭建 3.4 公共类介绍
谢谢你们的关注
12-31 265
RocketMQ 第二章 项目实战 3 环境搭建 3.4 公共类介绍
黑马程序员rocketmq第二章
qq_46198929的博客
10-04 817
黑马程序员rocketmq第二章
RocketMQ黑马笔记
06-08
"RocketMQ黑马笔记" RocketMQ是阿里巴巴开源的消息中间件，在阿里内部历经了双十一等很多高并发场景的考验，能够处理亿万级别的消息。2016年开源后捐赠给Apache，现在是Apache的一个顶级项目。目前RocketMQ在阿里云...
黑马程序员Javase笔记
01-18
"黑马程序员Javase笔记"是一个自学者在学习黑马程序员提供的Java全套课程过程中整理的笔记，主要涵盖了Java Standard Edition (Javase) 的核心内容。下面将详细讨论其中的关键知识点。 首先，DOS命令是操作系统中的...
黑马程序员 大事件案例程序
08-24
layui ajax 没有node.js功能都可用，高度类似。 黑马刘龙彬老师主讲的大事件项目，整体看完，给...最后，再次给黑马程序员和刘老师点个赞。 说明--ShowDoc https://www.showdoc.com.cn/escook?page_id=3707158761215217
教材源码_javaweb_黑马程序员Javaweb源码_
09-30
黑马程序员的Javaweb源码集是一个丰富的学习资源，包含实际项目案例和练习，覆盖了Web开发的基础到进阶内容。通过阅读和分析这些源码，学习者可以更好地理解Web开发流程，学习如何组织代码结构，以及掌握常见的设计...
黑马程序员第一期区块链视频源码
08-12
黑马程序员第一期区块链视频源码，根据视频自己敲了一遍，可以printChain，getBalance，createChain，send 不能允许欢迎来骂！
黑马rocketmq md文档
03-22
黑马rocketmq md文档
RocketMQ高级
cocoawork 丶的博客
09-12 189
1. 高级功能 1.1 消息存储 分布式队列因为有高可靠性的要求，所以数据要进行持久化存储。 消息生成者发送消息 MQ收到消息，将消息进行持久化，在存储中新增一条记录 返回ACK给生产者 MQ push 消息给对应的消费者，然后等待消费者返回ACK 如果消息消费者在指定时间内成功返回ack，那么MQ认为消息消费成功，在存储中删除消息，即执行第6步；如果MQ在指定时间内没有收到ACK，则认为消息消费失败，会尝试重新push消息,重复执行4、5、6步骤 MQ删除消息 1.1.1 存储介质 关系型数据库D
黑马学-MQ学习
dengfengling999的博客
01-05 731
在大多的情况下使用同步，大多情况下对并发没有更高的要求，相反我们对时效性要求较高，比如我去查询一个信息，而这个信息我需要立马在下面用到，比如查到一个订单，我要去查用户，必须用同步调用，因为异步调用呢，是我去通知你去干一件事，干完你不会告诉我，我不知道什么时候干完，我不能等待它的结果。比如，你不用知道它的结果，只是让它去干一件事，并且呢，你对吞吐量、并发的要求较高，还希望解除服务之间的耦合关系，那么需要使用异步通信。各个用户有不同的虚拟主机，VirtualHost，各个虚拟主机之间是看不到的，可以避免干扰。
RocketMQ 4.x入门到进阶
FaxBoy的博客
03-27 2079
RocketMQ 4.x使用（持续更新中......）第一章《安装搭建RocketMQ 4.x》新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowc...
RocketMQ高级篇
zhangsuhua0702的博客
01-04 546
RocketMQ学习之旅三 本文只要对RocketMQ消息的存储模型、高可用性机制、负载均衡、消息重试、死信队列和消费幂等等知识点做一些总结与分享。 一、存储介质 分布式队列因为有高可靠性的要求，所以数据要进行持久化存储，目前有如下两种存储介质： 关系型数据库DB Apache下开源的另一款MQ【ActiveMQ（默认采用的KahaDB做消息存储）】可选用JDBC的方式来做消息持久化，通过建...
Kafka、RabbitMQ、RocketMQ、ActiveMQ
黑马程序员广州中心的专栏
02-27 240
一、资料文档 Kafka：中。有kafka作者自己写的书，网上资料也有一些。rabbitmq：多。有一些不错的书，网上资料多。zeromq：少。没有专门写zeromq的书，网上的资料多是一些代码的实现和简单介绍。rocketmq：少。没有专门写rocketmq的书，网上的资料良莠不齐，官方文档很简洁，但是对技术细节没有过多的描述。activemq：多。没...
rocketmq 资料整理
梦之马
09-03 497
中文官网： http://rocketmq.cloud/zh-cn 含有 rocket 架构设计、最佳实践等 源码地址 https://github.com/apache/rocketmq web console项目(console-ng) https://github.com/apache/rocketmq-externals/tree/master/rocketmq-console spri...
黑马程序员java第一章
最新发布
06-07
《黑马程序员Java从入门到精通》是一本非常经典的Java学习教材，通常作为初学者的入门教程。第一章可能会涵盖Java基础，包括以下几个部分： 1. **Java概述**：介绍了Java语言的历史、平台无关性（JVM）、版本变迁和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值