RocketMq demo

最新推荐文章于 2024-03-04 20:08:13 发布
最新推荐文章于 2024-03-04 20:08:13 发布
阅读量1.1k 收藏
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42745404/article/details/112437381
版权

文章目录

pom文件添加依赖配置

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

	</dependencies>

简单demo

阻塞方式
Producer

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

public class Producer {

    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer  =new DefaultMQProducer("first");

        //设置nameServer地址
        producer.setNamesrvAddr("192.168.100.121:9876");
        producer.start();

        //发送topic 信息
        Message msg1 = new Message("myTopic","first 第一条".getBytes());
        Message msg2 = new Message("myTopic","first 第二条".getBytes());
        Message msg3 = new Message("myTopic","first 第三条".getBytes());

        //同步发送消息
        SendResult sendResult1 = producer.send(msg1);
        SendResult sendResult2 = producer.send(msg2);
        SendResult sendResult3 = producer.send(msg3);

        System.out.println(sendResult1);
        System.out.println(sendResult2);
        System.out.println(sendResult3);

        producer.shutdown();
        System.out.println("shut down");
    }
}

SendResult [sendStatus=SEND_OK, msgId=C0A86477000001F6DC6132685A070000, offsetMsgId=C0A8647900002A9F00000000006ADA3B, messageQueue=MessageQueue [topic=myTopic, brokerName=localhost.localdomain, queueId=3], queueOffset=0]
SendResult [sendStatus=SEND_OK, msgId=C0A86477000001F6DC6132685A9A0001, offsetMsgId=C0A8647900002A9F00000000006ADADD, messageQueue=MessageQueue [topic=myTopic, brokerName=localhost.localdomain, queueId=0], queueOffset=0]
SendResult [sendStatus=SEND_OK, msgId=C0A86477000001F6DC6132685A9F0002, offsetMsgId=C0A8647900002A9F00000000006ADB7F, messageQueue=MessageQueue [topic=myTopic, brokerName=localhost.localdomain, queueId=1], queueOffset=0]
shut down

Consumer

import java.util.List;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

public class Consumer {

    public static void main(String[] args)throws Exception {

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("firstConsumer");

        consumer.setNamesrvAddr("192.168.100.121:9876");

        // 每个consumer 关注一个topic

        // topic 关注的消息的地址
        // 过滤器 * 表示不过滤
        consumer.subscribe("myTopic", "*");

        consumer.registerMessageListener(new MessageListenerConcurrently() {

            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {

                for (MessageExt msg : msgs) {

                    System.out.println(new String(msg.getBody()));;
                }
                // 默认情况下 这条消息只会被 一个consumer 消费到 点对点
                // message 状态修改
                // ack
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        consumer.setMessageModel(MessageModel.CLUSTERING);
        consumer.start();
        System.out.println("Consumer 01 start...");
    }
}

异步发送

AsyProducer.java

package oliver.simple;

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;

public class AsyProducer {


    public static void main(String[] args) throws Exception{
        DefaultMQProducer producer  =new DefaultMQProducer("firstProducer");

        //设置nameServer地址
        producer.setNamesrvAddr("192.168.100.121:9876");
        producer.start();

        //发送topic 信息
        Message msg1 = new Message("myTopic","first 第三条".getBytes());

        //异步可靠发送消息//不用等着回馈，采用监听的方式
        producer.send(msg1, new SendCallback() {
            public void onSuccess(SendResult sendResult) {
               // ack 确认机制
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }

            public void onException(Throwable throwable) {
                System.out.println("抛出的异常-->"+throwable);
            }
        });
    }
}

直接发送，有去，但不确认发送成功

SendOneWayProducer.java

package oliver.simple;

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

public class SendOneWayProducer {

    public static void main(String[] args) throws MQClientException, RemotingException, InterruptedException {
        DefaultMQProducer producer  =new DefaultMQProducer("firstProducer");

        //设置nameServer地址
        producer.setNamesrvAddr("192.168.100.121:9876");
        producer.start();

        //发送topic 信息
        Message msg1 = new Message("myTopic","first 第一条".getBytes());

        //单向消息，不确定是否发送成功，没监听
        producer.sendOneway(msg1);

        producer.shutdown();
        System.out.println("shut down");
    }
}

tag过滤发送及接收

TagProducer.java

package oliver.simple;

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;

public class TagProducer {

    public static void main(String[] args) throws Exception{
        DefaultMQProducer producer  =new DefaultMQProducer("firstProducer");

        //设置nameServer地址
        producer.setNamesrvAddr("192.168.100.121:9876");
        producer.start();

        //发送topic 信息
        //tag一般是做过滤的作用，key一般是跟业务做关联
        Message msg1 = new Message("myTopic","tag-a","key-a","first 第三条".getBytes());

        //异步可靠发送消息//不用等着回馈，采用监听的方式
        producer.send(msg1, new SendCallback() {
            public void onSuccess(SendResult sendResult) {
                System.out.println(sendResult);
            }

            public void onException(Throwable throwable) {
                System.out.println("抛出的异常-->"+throwable);
            }
        });
    }
}

TagConsumer.java

package oliver.simple;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

import java.util.List;

public class TagConsumer {
    public static void main(String[] args)throws Exception {

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("firstConsumer");

        consumer.setNamesrvAddr("192.168.100.121:9876");

        // 每个consumer 关注一个topic

        // topic 关注的消息的地址
        // 过滤器 * 表示不过滤
        consumer.subscribe("myTopic","tag-a");

        consumer.registerMessageListener(new MessageListenerConcurrently() {

            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {

                for (MessageExt msg : msgs) {

                    System.out.println(new String(msg.getBody()));;
                }
                // 默认情况下 这条消息只会被 一个consumer 消费到 点对点
                // message 状态修改
                // ack
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        consumer.setMessageModel(MessageModel.BROADCASTING);
        consumer.start();
        System.out.println("Consumer tag 02 start...");
    }
}

sql过滤接收

这里注意，broker的配置要更改
去到conf的配置文件里
在broker.conf中添加配置

enablePropertyFilter=true

启动broker 加载指定配置文件

../bin/mqbroker -n 192.168.100.121:9876 -c broker.conf

SqlProducer.java

package oliver.simple;


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

public class SqlProducer {

    public static void main(String[] args)throws Exception {

        DefaultMQProducer producer = new DefaultMQProducer("xoxogp");

        // 设置nameserver地址
        producer.setNamesrvAddr("192.168.100.121:9876");
        producer.start();

        for (int i = 1; i <= 100; i++) {

            Message message = new Message("myTopic003", ("xxooxx:" + i ).getBytes());
            message.putUserProperty("age", String.valueOf(i));
            SendResult send = producer.send(message);

            System.out.println(send);
        }
        producer.shutdown();
        System.out.println("已经停机");

    }
}

SqlComsumer.java

package oliver.simple;

import java.util.List;

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 org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

public class SqlComsumer {

    public static void main(String[] args)throws Exception {

        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("xxoo0TAG-B");

        consumer.setNamesrvAddr("192.168.100.121:9876");

        MessageSelector messageSelector = MessageSelector.bySql("age >= 18 and age <= 28");

        consumer.subscribe("myTopic003",messageSelector );

        consumer.registerMessageListener(new MessageListenerConcurrently() {

            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {

                for (MessageExt msg : msgs) {

                    System.out.println(new String(msg.getBody()));;
                }

                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        
        consumer.setMessageModel(MessageModel.CLUSTERING);
        consumer.start();
        System.out.println("Consumer sql-filter start...");
    }
}

发送延迟设置

RocketMQ使用messageDelayLevel可以设置延迟投递
默认配置为

messageDelayLevel	1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
配置

在broker.conf中添加配置

messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h

这个配置项配置了从1级开始，各级延时的时间，可以修改这个指定级别的延时时间；

时间单位支持：s、m、h、d，分别表示秒、分、时、天；

使用

发送消息时设置

message.setDelayTimeLevel(1);

保证顺序发送，且顺序消费

队列先天支持FIFO模型，单一生产和消费者下只要保证使用MessageListenerOrderly监听器即可

顺序消费表示消息消费的顺序同生产者为每个消息队列发送的顺序一致，所以如果正在处理全局顺序是强制性的场景，需要确保使用的主题只有一个消息队列。

并行消费不再保证消息顺序，消费的最大并行数量受每个消费者客户端指定的线程池限制。

那么只要顺序的发送，再保证一个线程只去消费一个队列上的消息，那么他就是有序的。

跟普通消息相比，顺序消息的使用需要在producer的send()方法中添加MessageQueueSelector接口的实现类，并重写select选择使用的队列，因为顺序消息局部顺序，需要将所有消息指定发送到同一队列中。

保证有序参与因素

  • FIFO
  • 队列内保证有序
  • 消费线程

ProducerSelectQueue.java
发送到固定query里面

package oliver;

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

import java.util.List;

public class ProducerSelectQueue {

    public static void main(String[] args)throws Exception {

        DefaultMQProducer producer = new DefaultMQProducer("pgp01");

        producer.setNamesrvAddr("192.168.100.121:9876");


        producer.start();


        for (int i = 0; i < 20; i++) {

            Message message = new Message("xxoo007", ("hi!" + i).getBytes());

            producer.send(
                    // 要发的那条消息
                    message,
                    // queue 选择器 ，向 topic中的哪个queue去写消息
                    new MessageQueueSelector() {
                        // 手动 选择一个queue
                        public MessageQueue select(
                                // 当前topic 里面包含的所有queue
                                List<MessageQueue> mqs
                                ,
                                // 具体要发的那条消息
                                Message msg

                                // 对应到 send（） 里的 args
                                , Object arg) {
                            // TODO Auto-generated method stub

                            // 向固定的一个queue里写消息
                            MessageQueue queue = mqs.get(0);
                            // 选好的queue
                            return queue;
                        }
                    },
                    // 自定义参数
                    0, 2000);
        }

        //	producer.shutdown();
        System.out.println("已经停机");

    }
}

ComsumerSelectQueue.java
接收，线程数设置为1,代码注释为开启多个线程

package oliver;

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

import java.util.List;

public class ComsumerSelectQueue {

	public static void main(String[] args)throws Exception {
		
		DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("g02");
		
		consumer.setNamesrvAddr("192.168.100.121:9876");
		
		consumer.subscribe("xxoo007", "*");
		
		
		
		/**
		 * 
		 * 
		 * 
		 * 
		 * MessageListenerConcurrently   并发消费 / 开多个线程
		 * 
		 * 
		 */
//		consumer.registerMessageListener(new MessageListenerConcurrently() {
//
//			public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//
//				for (MessageExt msg : msgs) {
//
//					System.out.println(new String(msg.getBody()));;
//				}
//				return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
//			}
//		});

		
		/*
		 * 
		 * MessageListenerOrderly 顺序消费 ,对一个queue 开启一个线程，多个queue 开多个线程 
		 * 
		 * 
		 */
		
		
		// 
		// 最大开启消费线程数
		int consumeThreadMax=1;
		consumer.setConsumeThreadMax(consumeThreadMax);
		//  最小线程数
		int consumeThreadMin=1;
		consumer.setConsumeThreadMin(consumeThreadMin);
		consumer.registerMessageListener(new MessageListenerOrderly() {

			public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
				for (MessageExt msg : msgs) {

				System.out.println(new String(msg.getBody()) + " Thread:" + Thread.currentThread().getName());;
			}
			return ConsumeOrderlyStatus.SUCCESS;
			}
		});
		
		consumer.start();
		System.out.println("Consumer g02 start...");
	}
}

事务发送(这里要另外写一篇)

TrancationProducer.java

package oliver.transaction;

import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.TransactionListener;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;

public class TrancationProducer {

    public static void main(String[] args) throws Exception{
        TransactionMQProducer producer = new TransactionMQProducer("transactionProducerGroup");
        producer.setNamesrvAddr("192.168.100.121:9876");
        //回调
        producer.setTransactionListener(new TransactionListener() {
            public LocalTransactionState executeLocalTransaction(Message message, Object o) {
                //执行本地事务
                /*a();
                b();*/
                System.out.println("===============executeLocalTransaction=========");
                System.out.println("msg->"+new String(message.getBody()));
              return  LocalTransactionState.UNKNOW;
//                return LocalTransactionState.COMMIT_MESSAGE;
            }

            public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
                //broker端回调
                System.out.println("===============checkLocalTransaction=========");
                System.out.println("msg->"+new String(messageExt.getBody()));
                return LocalTransactionState.UNKNOW;
//                return LocalTransactionState.ROLLBACK_MESSAGE;
            }


        });
        producer.start();

        producer.sendMessageInTransaction(new Message("transactionProducerTopic","test transaction".getBytes()),null);

        System.out.println("=============test transaction end");
    }

}

分布式系统中的事务可以使用TCC（Try、Confirm、Cancel）、2pc来解决分布式系统中的消息原子性

RocketMQ 4.3+提供分布事务功能，通过 RocketMQ 事务消息能达到分布式事务的最终一致

RocketMQ实现方式

Half Message： 预处理消息，当broker收到此类消息后，会存储到RMQ_SYS_TRANS_HALF_TOPIC的消息消费队列中

检查事务状态： Broker会开启一个定时任务，消费RMQ_SYS_TRANS_HALF_TOPIC队列中的消息，每次执行任务会向消息发送者确认事务执行状态（提交、回滚、未知），如果是未知，等待下一次回调。

超时： 如果超过回查次数，默认回滚消息

TransactionListener的两个方法
executeLocalTransaction

半消息发送成功触发此方法来执行本地事务

checkLocalTransaction

broker将发送检查消息来检查事务状态，并将调用此方法来获取本地事务状态

本地事务执行状态

LocalTransactionState.COMMIT_MESSAGE

执行事务成功，确认提交

LocalTransactionState.ROLLBACK_MESSAGE

回滚消息，broker端会删除半消息

LocalTransactionState.UNKNOW

暂时为未知状态，等待broker回查

参考官网地址

官方文档

自行车在路上
关注
专栏目录
RocketMQ 三种发消息的方式
Hebe
11-17 5727
本文主要 使用 RocketMQ-Spring 封装提供的RocketMQTemplate，实现三种(同步、异步、oneway)发送消息的方式。 1、引入pom.xml 依赖 <!-- 实现对 RocketMQ 的自动化配置 --> <dependency> <groupId>org.apache.rocketmq</groupId> <artifactI..
RocketMq的简单demo
qq_43560721的博客
12-16 3810
首先要确定RocketMq安装成功，环境配置ok，并且启动了。 参考：Rocketmq安装与环境配置_小小舍的博客-CSDN博客 依赖： <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.3.0<
rocketmq demo
weixin_34295316的博客
07-03 408
首先下载rocketmq，启动需要指定rocketmq home目录 cd github git clone -b develop https://github.com/apache/incubator-rocketmq.git 代码结构代码 收藏代码 whatsmars-mq |-src |-main |-java...
rocketmqDemo
02-24
rocketmq插件，并含有demo教程，能够很好的帮助初学者了解，掌握rocketmq
rocketmq本地demo搭建
qishiheyongshi的专栏
07-28 1894
rocket本地demo搭建
rocketMQ demo案例
05-07
rocketMQ demo案例 详细文档：...
RocketMQ demo
07-27
当然，我可以提供一个简单的RocketMQ示例。 首先，你需要按照RocketMQ的安装指南在你的环境中安装和配置RocketMQ。完成后，你可以开始编写你的RocketMQ示例。 ```java import org.apache.rocketmq.client.producer...
RocketMQ代码demo.zip
04-15
在"rocketMQ-demo"这个压缩包中，应该包含了一个完整的示例项目，包括了上述的配置文件、Producer和Consumer的实现，以及可能的测试代码。你可以通过导入这个项目到IDE，运行并查看日志，以了解如何实际操作RocketMQ...
springboot-rocketmq-demo.zip
04-09
标题中的"springboot-rocketmq-demo.zip"表明这是一个关于Spring Boot整合RocketMQ的示例项目。RocketMQ是阿里巴巴开源的一款分布式消息中间件，而Spring Boot是基于Spring框架的高度集成了许多开发工具和配置的轻量...
阿里云rocketmq消息队列对接demo
01-24
该资源为在购买了阿里云中间件产品rocketmq消息队列之后，使用的连接rocketmq的demo工程，该程序以 Java 为例，包括普通消息、事务消息、定时消息的测试代码，以及相关 Spring 的配置示例，同时提供tcp连接的程序。
RocketMQ 的小demo
11-13
初学者可以来学习一下，rocketMQ的简单的小demo 简单易懂
rocketmq实例代码
11-09
RocketMQ是一个纯java、分布式、队列模型的开源消息中间件，前身是Metaq，当 Metaq 3.0发布时，产品名称改为 RocketMQ。
rocketmq-demo.zip
09-01
Apache RocketMQ入门demo，用来理解RocketMQ的基本原理，附带必要代码注释。基于maven的用Java api编写的Producer和Consumer；
RocketMQ消息队列demo
01-09
RocketMQ消息队列demo,输入IP端口，就可以对消息队列进行操作，发布消息，订阅消息。
消息中间件 RocketMQ 发布和订阅 Demo
03-27
java编写的RocketMQ入门demo，maven 更新依赖，可直接运行Producer和Consumer 简单进行测试
RocketMQ生产消费Demo（原生API）
最新发布
qq_35316141的博客
03-04 447
/
rocketMq-demo
01-01 4658
rocketMq-demo 前言 jar包预备 demo 前言 前面一面博文写了RocketMq的配置安装，这里记录一下自己的demo。 jar包预备 我用的maven来管理项目，加入maven依赖： com.alibaba.rocketmq rocketmq-client 3.2.6 Producer package com.yyp.t
一文入门rocketmq（扫盲版-附示例demo）
weixin_42956626的博客
01-16 733
1、什么是Rocketmq 消息队列 RocketMQ 是阿里巴巴集团自主研发的专业消息中间件，基于高可用分布式集群技术，提供消息订阅和发布、消息轨迹查询以及定时（延时）消息、资源统计、监控报警等一系列消息云服务，是企业级互联网架构的核心产品。 消息队列 RocketMQ 历史超过9年，为分布式应用系统提供异步解耦、削峰填谷的能力，同时具备海量消息堆积、高吞吐、可靠重试等互联网应用所需的特性，是阿...
RocketMq搭建demo
qq_24516549的博客
03-12 1385
1.在linux上安装RocketMq 1.1安装git yum update yum install git git --version 1.2安装wget依赖包 yum install wget 1.3安装jdk yum install java-1.8.0-openjdk* -y 1.4安装maven yum install maven 1.5安装RocketMQ #使用git拉取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值