手搭手RocketMQ发送消息

已于 2024-03-14 21:39:38 修改
阅读量678 收藏 17
点赞数 13
分类专栏： java 文章标签： rocketmq
于 2024-03-13 22:16:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47268883/article/details/136693190
版权

消息中间件的对比

消息中间件

ActiveMQ

RabbitMQ

RocketMQ

kafka

开发语言

java

erlang

java

scala

单击吞吐量

万级

万级

10万级

10万级

时效性

ms

us

ms

ms

可用性

高(主从架构)

高(主从架构)

非常高(主从架构)

非常高(主从架构)

消息中间件: activeMQ:java（jms协议），性能一般，吞吐量低。rabbitMQ:erlang(amqp协议)，性能好，功能丰富，吞吐量一般。rocketMQ：java，性能好，吞吐量丰富，功能丰富。Kafka: scala，吞吐量最大，功能单一，大数据领域

RocketMQ 是阿里开源的分布式消息中间件，跟其它中间件相比，RocketMQ 的特点是纯JAVA实现，是一套提供了消息生产，存储，消费全过程API的软件系统。


RocketMQ的作用：数据收集、限流削峰、异步解耦
数据收集
分布式系统会产生海量级数据流，如:业务日志、监控数据、用户行为等。针对这些数据流进行实时或批量采集汇总，然后对这些数据流进行大数据分析，这是当前互联网平台的必备技术。通过MQ完成此类数据收集是最好的选择。

限流削峰
MQ可以将系统的超量请求暂存其中，以便系统后期可以慢慢进行处理，从而避免了请求的丢失或系统被压垮。

异步解耦
上游系统对下游系统的调用若为同步调用，则会大大降低系统的吞吐量与并发度，且系统耦合度太高、而异步调用则会解决这些问题。所以两层之间若要实现由同步到异步的转化，一般性做法就是，在这两层间添加一个MQ层。

rocketmq.apache.org

Broker:经纪人(经理人)

Topic主题：消息区分，分类,虚拟结构

Queue：消息队列

Apache RocketMQ 是一款低延迟、高并发、高可用、高可靠的分布式消息中间件。消息队列 RocketMQ 可为分布式应用系统提供异步解耦和削峰填谷的能力，同时也具备互联网应用所需的海量消息堆积、高吞吐、可靠重试等特性。

发送消息

发送同步消息

同步消息发送后会用一个返回值，也就是MQ服务器接收到消息返回的一个确认，这种方式非常安全，但是性能就没那么高，而在MQ集群中，也是要等到所有的从机都复制了消息以后才会返回，这种方式适合重要消息的场景

@Test
void rocketmqProducerTest() throws Exception {
//创建生产者
DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
//连接namesrv
producer.setNamesrvAddr("192.168.68.133:9876");
//启动
producer.start();
//创建消息
Message message = new Message("Topic","消息".getBytes());
SendResult send = producer.send(message);
System.out.println("发送状态"+send.getSendStatus());
//关闭生产者
producer.shutdown();
}

@Test
void rocketmqConsumerTest() throws Exception {
//创建消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerTest");
//连接namesrv
consumer.setNamesrvAddr("192.168.68.133:9876");
//订阅主题 *表示该主题的所有消息
consumer.subscribe("Topic","*");

//设置监听器(一直,异步回调方式)
consumer.registerMessageListener(new MessageListenerConcurrently() {
//消费方法
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//业务处理

for (MessageExt messageExt : msgs) {
System.out.println("消费了："+new String(messageExt.getBody()));
}
System.out.println("消费者上下文"+context);
//CONSUME_SUCCESS成功 RECONSUME_LATER失败
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});

//启动
consumer.start();
//挂起当前jvm
System.in.read();
//关闭
//consumer.shutdown();
}

发送异步消息

异步消息常用在对响应时间敏感的业务场景，发送端不能容忍长时间等待Broker的响应。发送完后会有一个异步消息通知

@Test
void aysncProducerTest() throws Exception {
//创建生产者
DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
//连接namesrv
producer.setNamesrvAddr("192.168.68.133:9876");
//启动
producer.start();
//创建消息
Message message = new Message("aysncTopic","异步消息".getBytes());
producer.send(message, new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
System.out.println("发送成功"+sendResult);
}

@Override
public void onException(Throwable throwable) {
System.err.println("发送失败"+throwable);
}
});
System.out.println("执行了");
//关闭生产者
//producer.shutdown();
//挂起当前jvm
System.in.read();
}

@Test
void aysncConsumerTest() throws Exception {
//创建消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerTest");
//连接namesrv
consumer.setNamesrvAddr("192.168.68.133:9876");
//订阅主题 *表示该主题的所有消息
consumer.subscribe("aysncTopic","*");

//设置监听器(一直,异步回调方式)
consumer.registerMessageListener(new MessageListenerConcurrently() {
//消费方法
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//业务处理

for (MessageExt messageExt : msgs) {
System.out.println("消费了："+new String(messageExt.getBody()));
}
System.out.println("消费者上下文"+context);
//CONSUME_SUCCESS成功 RECONSUME_LATER失败
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});

//启动
consumer.start();
//挂起当前jvm
System.in.read();
//关闭
//consumer.shutdown();
}

发送单向消息

单向消息发送这种方式不关心发送结果的场景，这种方式吞吐量大，但存在消息丢失的风险。使用案例：日志信息发送

@Test
void OnewayProducerTest()throws Exception{
//创建生产者
DefaultMQProducer producer = new DefaultMQProducer("Oneway");
//连接namesrv
producer.setNamesrvAddr("192.168.68.133:9876");
//启动
producer.start();
//创建消息
Message message = new Message("Oneway","单向消息

".getBytes());
//发送消息
producer.sendOneway(message);
//关闭生产者
producer.shutdown();
}

@Test
void OnewayConsumerTest() throws Exception {
//创建消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerTest");
//连接namesrv
consumer.setNamesrvAddr("192.168.68.133:9876");
//订阅主题 *表示该主题的所有消息
consumer.subscribe("Oneway","*");

//设置监听器(一直,异步回调方式)
consumer.registerMessageListener(new MessageListenerConcurrently() {
//消费方法
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//业务处理

for (MessageExt messageExt : msgs) {
System.out.println("消费了："+new String(messageExt.getBody()));
}
System.out.println("消费者上下文"+context);
//CONSUME_SUCCESS成功 RECONSUME_LATER失败
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
//启动
consumer.start();
//挂起当前jvm
System.in.read();
//关闭
//consumer.shutdown();
}

发送延时消息

发送延时消息，顾名思义。场景：比如淘宝商城下单后，并未支付，有30分钟未支付订单状态

@Test
void delayProducerTest()throws Exception{
//创建生产者
DefaultMQProducer producer = new DefaultMQProducer("delayGroup");
//连接namesrv
producer.setNamesrvAddr("192.168.68.133:9876");
//启动
producer.start();
//创建消息
Message message = new Message("delay","延迟消息".getBytes());
//设置延时 根据官方延时等级
message.setDelayTimeLevel(2);
//发送消息
producer.sendOneway(message);
//关闭生产者
producer.shutdown();
}

@Test
void delayConsumerTest() throws Exception {
//创建消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerTest");
//连接namesrv
consumer.setNamesrvAddr("192.168.68.133:9876");
//订阅主题 *表示该主题的所有消息
consumer.subscribe("delay","*");

//设置监听器(一直,异步回调方式)
consumer.registerMessageListener(new MessageListenerConcurrently() {
//消费方法
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//业务处理

for (MessageExt messageExt : msgs) {
System.out.println("消费了："+new String(messageExt.getBody()));
}
System.out.println("消费者上下文"+context);
//CONSUME_SUCCESS成功 RECONSUME_LATER失败
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
//启动
consumer.start();
//挂起当前jvm
System.in.read();
//关闭
//consumer.shutdown();
}

发送批量消息

批量消息：可以一次性发送一组消息

@Test
void delayProducerTest()throws Exception{
//创建生产者
DefaultMQProducer producer = new DefaultMQProducer("delayGroup");
//连接namesrv
producer.setNamesrvAddr("192.168.68.133:9876");
//启动
producer.start();
//创建消息
//批量消息
List<Message> messages = Arrays.asList(
new Message("delay","批量消息1".getBytes()),
new Message("delay","批量消息2".getBytes()),
new Message("delay","批量消息3".getBytes())
);
//发送消息
producer.send(messages);
//关闭生产者
producer.shutdown();
}

发送带标签消息

RocketMQ提供消息过滤功能，可根据业务逻辑区分，带有A标签的被A消费，带有B标签的被B消费

@Test
void TagProducerTest()throws Exception{
//创建生产者
DefaultMQProducer producer = new DefaultMQProducer("TagGroup");
//连接namesrv
producer.setNamesrvAddr("192.168.68.133:9876");
//启动
producer.start();
//创建消息
//批量消息
Message message1 = new Message("tagTopic", "tagA", "tag标签内容A".getBytes());
Message message2 = new Message("tagTopic", "tagB", "tag标签内容B".getBytes());
//发送消息
producer.send(message1);
producer.send(message2);
//关闭生产者
producer.shutdown();
}

@Test
void TagAConsumerTest() throws Exception {
//创建消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerTest");
//连接namesrv
consumer.setNamesrvAddr("192.168.68.133:9876");
//订阅主题 *表示该主题的所有消息
consumer.subscribe("tagTopic","tagA || tagB");

//设置监听器(一直,异步回调方式)
consumer.registerMessageListener(new MessageListenerConcurrently() {
//消费方法
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//业务处理

for (MessageExt messageExt : msgs) {
System.out.println("消费了："+new String(messageExt.getBody()));
}
System.out.println("消费者上下文"+context);
//CONSUME_SUCCESS成功 RECONSUME_LATER失败
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
//启动
consumer.start();
//挂起当前jvm
System.in.read();
//关闭
//consumer.shutdown();
}

@Test
void TagBConsumerTest() throws Exception {
//创建消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerTest");
//连接namesrv
consumer.setNamesrvAddr("192.168.68.133:9876");
//订阅主题 *表示该主题的所有消息
consumer.subscribe("tagTopic","tagB");

//设置监听器(一直,异步回调方式)
consumer.registerMessageListener(new MessageListenerConcurrently() {
//消费方法
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//业务处理

for (MessageExt messageExt : msgs) {
System.out.println("消费了："+new String(messageExt.getBody()));
}
System.out.println("消费者上下文"+context);
//CONSUME_SUCCESS成功 RECONSUME_LATER失败
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
//启动
consumer.start();
//挂起当前jvm
System.in.read();
//关闭
//consumer.shutdown();
}

 发送顺序消息

发送的消息要保证消息是一定有序的，顺序消息，发送到同一个队列

实体类

@Data
@AllArgsConstructor
public class MessageM {
private int userID;
private String desc;
}

顺序消息，发送到同一个队列

private List<MessageM> messageMs = Arrays.asList(
new MessageM(1,"下单"),
new MessageM(1,"付款"),
new MessageM(1,"配送"),
new MessageM(2,"下单"),
new MessageM(2,"付款"),
new MessageM(2,"配送")
);

@Test
void orderProducerTest() throws Exception {
//创建生产者
DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
//连接namesrv
producer.setNamesrvAddr("192.168.211.131:9876");
//启动
producer.start();

messageMs.forEach(messageM -> {
//创建消息
Message message = new Message("orderMsg",messageM.toString().getBytes());
//发送顺序消息，发送到同一个队列
try {
//相同的userID去相同的队列
producer.send(
message,
new MessageQueueSelector() {
@Override
public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
//选择队列
int hashCode = o.toString().hashCode();
int i = hashCode % list.size();
return list.get(i);
}
},
messageM.getUserID());
} catch (MQClientException e) {
throw new RuntimeException(e);
} catch (RemotingException e) {
throw new RuntimeException(e);
} catch (MQBrokerException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
//关闭生产者
producer.shutdown();
}

@Test
void orderConsumerTest() throws Exception {
//创建消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ConsumerTest");
//连接namesrv
consumer.setNamesrvAddr("192.168.211.131:9876");
//订阅主题 *表示该主题的所有消息
consumer.subscribe("orderMsg","*");

//设置监听器(一直,异步回调方式)
//MessageListenerConcurrently 并发模式，多线程
//MessageListenerOrderly 顺序模式，单线程
consumer.registerMessageListener(new MessageListenerOrderly() {
//消费方法
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
System.out.println("当前线程ID"+Thread.currentThread().getId());
return ConsumeOrderlyStatus.SUCCESS;
}
});
//启动
consumer.start();
//挂起当前jvm
System.in.read();
//关闭
//consumer.shutdown();
}

发送带key消息

Message ID是MQ消息生产的唯一标识

@Test

void KeyProducerTest()throws Exception{

    //创建生产者

    DefaultMQProducer producer = new DefaultMQProducer("KeyGroup");

    //连接namesrv

    producer.setNamesrvAddr("192.168.211.131:9876");

    //启动

    producer.start();

    //自身业务key唯一

    String Key = UUID.randomUUID().toString();

    System.out.println("key："+Key);

    //创建消息

    Message message = new Message("KeyTopic", "Key",Key, "带Key".getBytes());

    //发送消息s

    producer.send(message);

    //关闭生产者

    producer.shutdown();

}



@Test

void KeyAConsumerTest() throws Exception {

    //创建消费者

    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("KeyConsumerTest");

    //连接namesrv

    consumer.setNamesrvAddr("192.168.211.131:9876");

    //订阅主题 *表示该主题的所有消息

    consumer.subscribe("KeyTopic","Key");



    //设置监听器(一直,异步回调方式)

    consumer.registerMessageListener(new MessageListenerConcurrently() {

        //消费方法

        @Override

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

    //业务处理



            for (MessageExt messageExt : msgs) {

                System.out.println("消费了："+new String(messageExt.getBody()));

                System.out.println("消费到了key："+messageExt.getKeys());

            }

            System.out.println("消费者上下文"+context);

    //CONSUME_SUCCESS成功 RECONSUME_LATER失败

            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;

        }

    });

    //启动

    consumer.start();

    //挂起当前jvm

    System.in.read();

    //关闭

    //consumer.shutdown();

}

QGS-CD
关注
  • 13
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
一文详解RabbitMQ的发送与接收。
2301_76607156的博客
04-20 2245
消息队列呢，其实用法都是一样的，只是各个开源消息队列的侧重点稍有不同，我们应该根据我们自己的项目需求来决定我们应该选取什么样的消息队列来为我们的项目服务，这个项目选型的工作一般都是开发组长帮你们做了，一般是轮不到我们来做的，但是面试的时候可能会考察相关知识，所以这几种消息队列我们都应该有所涉猎。上面说了消息队列带来的好处以及问题，而这些不在我们今天这篇的讨论范围之内，我打算之后再写这些，我们今天要做的是搭建出一个消息队列环境，让大家感受一下基础的发消息与消费消息，更高级的问题会放在以后讨论。
消息中间件—RocketMQ消息发送
m0_62714732的博客
10-26 602
大道至简，消息队列可以简单概括为：“一发一存一收”，在这三个过程中消息发送最为简单，也比较容易入手，适合初中阶童鞋作为MQ研究和学习的切入点。因此，本篇主要从一条消息发送为切入点，详细阐述在RocketMQ这款分布式消息队列中发送一条普通消息的大致流程和细节。 一、RocketMQ网络架构图 RocketMQ分布式消息队列的网络部署架构图如下图所示（其中，包含了生产者Producer发送普通消息至集群的两条主线） RocketMQ部署架构.jpg 对于上图中几个角色的说明： （1）Na
系列五（实战）、发送 & 接收同步消息（Java操作RocketMQ）
仰望星空，脚踏实地！安全感是自己给的，努力才是一辈子的安全感。
12-25 789
发送 & 接收同步消息（Java操作RocketMQ）
MQ消息传递方式
weixin_57763462的博客
06-16 694
有很多个人订阅报纸，也有人可能和我订阅了相同的报纸。消息的可靠性设计，目前有2种模式：模式1是采用Notify的方式，先发送半消息，业务操作成功后最后提交完整消息，同时提供业务操作的检查接口，这种模式实现消息的最终一致性；消息去重设计，也有2种模式：模式1是消费者根据自己的业务实现去重，模式2是在消费者端增加一个数据库表专门记录已经消费过的消息，不需要消费者根据业务去做去重。企业级的MQ不仅仅实现了简单的消息中转站的功能，还实现了消息生产者和消息消费者的认证功能（即他们能消费和生产哪些具体的topic）。
Mq消息的发送与接收
weixin_62108279的博客
05-18 364
3 编写MQ配置类，配置交换机。
消息队列——RabbitMq
weixin_45080272的博客
05-28 4298
一、消息队列的使用场景 一、消息队列的使用场景) 一、消息队列的使用场景 异步处理 应用解耦 流量削锋 消息通讯 【1】异步处理：场景说明：用户注册后，需要发注册邮件和注册短信。 引入消息队列后架构如下：用户的响应时间=注册信息写入数据库的时间，例如50毫秒。发注册邮箱、发注册短信写入消息队列后，直接返回客户端，因写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是50毫秒。 按照传统的做法： ①、串行方式，将注册信息写入数据库成功后，发注册邮件，再发送注册短信，以上三个成功后，返回客户端。可
消息队列之RocketMQ
ylx1066863710的博客
03-02 291
RocketMQ 是阿里开源的消息中间件，基于发布和订阅模型, 它是一个开源的分布式消息传递和流式数据平台. 一、RocketMQ架构 NameService NameServer是一个几乎无状态节点, 可集群部署, 节点之间无任何信息同步。 管理broker: broker服务器启动时会注册到NameServer上，并且两者之间保持心跳监测机制, 从而保证NameServer知道broker的存活状态； 路由信息管理: 每一台NameServer都存有全部的broker集群信息和生产者/消费者客户端的
手搭组合风速simulink模型
09-18
手搭组合风速simulink模型
逻辑回归LR手搭模型（初学者）
05-11
尽管sklearn里面有逻辑回归的包可以直接拿来用，但是为了学习逻辑回归的底层原理，我还是手写了一版，上传kaggle后准确率0.7，肯定不如第三方的包好。关键是学习的过程，而不仅仅是作为调包侠。...
完整资源：从零开始手搭的React服务端渲染框架
最新发布
06-11
React服务端渲染，使用方式： 1、到node_server文件夹下，执行npm install，然后执行node app.js，启动后端接口的服务器(端口为4000，用其他语言实现均可) 2、npm install nodemon npm-run-all -g 全局安装nodemon...
mq发送通道问题解决方法
03-26
1.查看mq日志，如果有通道序列号不正确的错误，说明需要reset channel； 2.ping ip，如果ip通，再telnet ip 端口,如果通,证明网络无故障，不通则协调网络管理员处理； 3.ip、端口均正常，查看端口是否被占用，或者端口状态是否正确，（一般每个发送通道都会有一个特定的端口） 命令：netstat -an|grep 端口号
三种Java向MQ发送消息的方法 -- java代码
10-02
此java代码分别实现了三种向WebSphere MQ队列发送消息的方法
java程序利用mq发送消息
09-21
java代码利用本地的mq配置，发送消息。从A队列管理至B队列管理器。
JAVA发送MQ信息
08-23
MQConnector.java MQ java发送.rar
springboot2.X.zip
05-21
**SpringBoot2.X详解** SpringBoot是由Pivotal团队提供的全新框架，其设计目标是用来简化新Spring应用的初始搭建以及开发过程。它集成了大量常用的第三方库配置，如Redis、MongoDB、JPA、RabbitMQ、Quartz等，只...
基于simulink的光伏模型搭建,供大家参考学习用
09-13
在 MATLAB 的 Simulink 环境中，光伏模型的构建是一个重要的研究领域，尤其对于能源工程、电力系统以及环境科学的学生和专业人士来说。Simulink 是一款强大的仿真工具，可以用于模拟各种复杂的动态系统，包括电力...
MQ消息的创建、发送和接收实例
Aee654321的博客
03-20 426
MQ消息的创建、发送和接收实例
RocketMQ消息发送
qq_27061805的博客
04-08 4371
RocketMQ消息发送 RocketMQ 支持3 种消息发送方式： 同步 （sync）、异步（async）、单向（oneway）。 同步：发送者向 MQ 执行发送消息API 时，同步等待，直到消息服务器返回发送结果。 异步：发送者向MQ 执行发送消息API 时，指定消息发送成功后的回调函数，然后调用消息发送API 后，立即返回，消息发送者线程不阻塞，直到运行结束，消息发送成功或失败的回调任务在一个新的线程中返回。 单向：消息发送者向MQ 执行发送消息API 时，直接返回，不等待消息服务器的结果
RabbitMQ
咖啡的博客
11-18 471
当初我学RabbitMQ的时候，第一时间就上GitHub找相应的教程，但是令我很失望的是没有找到，Spring，Mybatis之类的教程很多，而RabbitMQ的教程几乎找不到，看的最多的就是朱小厮大佬的博客。后来想着索性自己总结一下吧，有不恰当的地方欢迎小伙伴指出。 这篇文章主要是对着我在GitHub上的源码解释的，因此本文并没有太多的源码。写了挺长时间的，为了防止迷路，欢迎大家star和fork github地址：https://github.com/erlieStar/rabbitmq-exa
centos7手搭kubernetes
09-22
根据提供的引用内容，手搭CentOS 7上的Kubernetes需要执行以下操作： 1. 在`/etc/kubernetes/config`文件中，向`KUBE_ETCD_SERVERS`变量中添加etcd服务器的地址。可以使用以下命令将地址添加到文件中： ``` sudo ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

QGS-CD

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值