zookeeper分布式队列

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

一、简介

在此介绍基于zookeeper实现的分布式队列。包括类似jdk队列的简单队列SimpleDistributedQueue、

分布式队列DistributedQueue、带Id的分布式队列DistributedIdQueue、带优先级的分布式队列DistributedPriorityQueue。

二、添加maven依赖

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.6</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>4.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-client</artifactId>
    <version>4.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>4.0.0</version>
</dependency>
三、简单队列SimpleDistributedQueue

简单队列SimpleDistributedQueue和jdk中队列类似，拥有offer()、take()方法。

示例代码：

import org.apache.commons.lang3.StringUtils;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.queue.SimpleDistributedQueue;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class ZookeeperSimpleDistributedQueueMain {
    public static void main(String[] args) throws Exception {
        //创建zookeeper客户端
        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
        client.start();

        //指定锁路径
        String lockPath = "/zkLockRoot/lock_1";
        //创建分布式队列
        SimpleDistributedQueue simpleDistributedQueue = new SimpleDistributedQueue(client,lockPath);

        //生成线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        //生产
        BiConsumer<SimpleDistributedQueue,String> putConsumer = (queue, item) -> {
            try {
                Callable<Boolean> call = () -> {
                    try {
                        TimeUnit.SECONDS.sleep((int)(Math.random()*10));
                        //向队尾中添加数据
                        queue.offer(item.getBytes());
                        System.out.println(Thread.currentThread() + "  put : "+ item);
                    } catch (Exception e) {
                    }
                    return true;
                };
                executor.submit(call);
            } catch (Exception e) {
            }
        };
        //消费
        Consumer<SimpleDistributedQueue> getConsumer = (queue) -> {
            try {
                Callable<Boolean> call = () -> {
                    try {
                        while(true){
                            //从队首取出数据
                            byte[] dataByte = queue.take();
                            String data = new String(dataByte);
                            if(StringUtils.isBlank(data)){
                                break;
                            }
                            System.out.println(Thread.currentThread() + "  get : "+ data);
                        }
                    } catch (Exception e) {
                    }
                    return true;
                };
                executor.submit(call);
            } catch (Exception e) {
            }
        };

        //分布式队列测试(5个线程生产)
        System.out.println("5个并发线程生产,测试分布式队列");
        //5个生产线程
        for (int i = 0; i < 10; i++) {
            putConsumer.accept(simpleDistributedQueue, "item"+i);
        }
        //分布式队列测试(2个线程生产)
        System.out.println("2个并发线程消息,测试分布式队列");
        //2个消费线程
        for (int i = 0; i < 2; i++) {
            getConsumer.accept(simpleDistributedQueue);
        }

        executor.shutdown();
        TimeUnit.SECONDS.sleep(20);
        client.close();
    }
}
输出：

Thread[pool-3-thread-10,5,main]  put : item9
Thread[pool-3-thread-12,5,main]  get : item9
Thread[pool-3-thread-4,5,main]  put : item3
Thread[pool-3-thread-12,5,main]  get : item3
Thread[pool-3-thread-3,5,main]  put : item2
Thread[pool-3-thread-12,5,main]  get : item2
Thread[pool-3-thread-6,5,main]  put : item5
Thread[pool-3-thread-12,5,main]  get : item5
Thread[pool-3-thread-5,5,main]  put : item4
Thread[pool-3-thread-9,5,main]  put : item8
Thread[pool-3-thread-11,5,main]  get : item4
Thread[pool-3-thread-12,5,main]  get : item8
Thread[pool-3-thread-7,5,main]  put : item6
Thread[pool-3-thread-8,5,main]  put : item7
Thread[pool-3-thread-11,5,main]  get : item6
Thread[pool-3-thread-12,5,main]  get : item7
Thread[pool-3-thread-2,5,main]  put : item1
Thread[pool-3-thread-1,5,main]  put : item0
Thread[pool-3-thread-11,5,main]  get : item1
Thread[pool-3-thread-12,5,main]  get : item0

四、分布式队列DistributedQueue

分布式队列DistributedQueue和消息队列类似，需要定义消费监听器、序列化方式。

示例代码：

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.queue.DistributedQueue;
import org.apache.curator.framework.recipes.queue.QueueBuilder;
import org.apache.curator.framework.recipes.queue.QueueConsumer;
import org.apache.curator.framework.recipes.queue.QueueSerializer;
import org.apache.curator.framework.state.ConnectionState;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;

public class ZookeeperDistributedQueueMain {
    public static void main(String[] args) throws Exception {
        //创建zookeeper客户端
        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
        client.start();

        //指定锁路径
        String lockPath = "/zkLockRoot/lock_1";

        //消费监听器
        QueueConsumer<String> queueConsumer = new QueueConsumer<String>() {
            //消费队列数据
            @Override
            public void consumeMessage(String message) throws Exception {
                System.out.println("message: " + message);
            }

            @Override
            public void stateChanged(CuratorFramework client, ConnectionState newState) {

            }
        };

        //序列化
        QueueSerializer<String> queueSerializer = new QueueSerializer<String>() {
            @Override
            public byte[] serialize(String item) {
                return item.getBytes();
            }

            @Override
            public String deserialize(byte[] bytes) {
                return new String(bytes);
            }
        };

        //创建分布式队列
        QueueBuilder<String> distributedBuilder = QueueBuilder.builder(client, queueConsumer, queueSerializer, lockPath);
        DistributedQueue<String> distributedQueue = distributedBuilder.buildQueue();
        distributedQueue.start();

        //生成线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        //生产
        BiConsumer<DistributedQueue<String>, String> putConsumer = (queue, item) -> {
            try {
                Callable<Boolean> call = () -> {
                    try {
                        //向队尾添加数据
                        queue.put(item);
                        System.out.println(Thread.currentThread() + "  put : "+ item);
                    } catch (Exception e) {
                    }
                    return true;
                };
                executor.submit(call);
            } catch (Exception e) {
            }
        };

        //分布式队列测试(5个线程生产)
        System.out.println("5个并发线程生产,测试分布式队列");
        //5个生产线程
        for (int i = 0; i < 5; i++) {
            putConsumer.accept(distributedQueue, "item"+i);
        }

        executor.shutdown();
        TimeUnit.SECONDS.sleep(20);
        distributedQueue.close();
        client.close();
    }
}
输出：

5个并发线程生产,测试分布式队列
Thread[pool-4-thread-2,5,main]  put : item1
Thread[pool-4-thread-1,5,main]  put : item0
Thread[pool-4-thread-3,5,main]  put : item2
Thread[pool-4-thread-5,5,main]  put : item4
Thread[pool-4-thread-4,5,main]  put : item3
message: item1
message: item0
message: item2
message: item4
message: item3

五、带Id的分布式队列DistributedIdQueue

带Id的分布式队列DistributedIdQueue每条数据可以指定id,也可根据此id对数据进行删除等操作，

其它的和分布式队列DistributedQueue类似。

示例代码：

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.queue.*;
import org.apache.curator.framework.state.ConnectionState;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;

public class ZookeeperDistributedIdQueueMain {
    public static void main(String[] args) throws Exception {
        //创建zookeeper客户端
        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
        client.start();

        //指定锁路径
        String lockPath = "/zkLockRoot/lock_1";

        //消费者
        QueueConsumer<String> queueConsumer = new QueueConsumer<String>() {
            @Override
            public void consumeMessage(String message) throws Exception {
                System.out.println("message: " + message);
            }

            @Override
            public void stateChanged(CuratorFramework client, ConnectionState newState) {

            }
        };

        //序列化
        QueueSerializer<String> queueSerializer = new QueueSerializer<String>() {
            @Override
            public byte[] serialize(String item) {
                return item.getBytes();
            }

            @Override
            public String deserialize(byte[] bytes) {
                return new String(bytes);
            }
        };

        //创建分布式队列
        QueueBuilder<String> distributedBuilder = QueueBuilder.builder(client, queueConsumer, queueSerializer, lockPath);
        DistributedIdQueue<String> distributedIdQueue = distributedBuilder.buildIdQueue();
        distributedIdQueue.start();

        //生成线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        //生产
        BiConsumer<DistributedIdQueue<String>, String> putConsumer = (queue, item) -> {
            try {
                Callable<Boolean> call = () -> {
                    try {
                        //向队尾添加数据，同时指定id
                        queue.put(item, item);
                        System.out.println(Thread.currentThread() + "  put : "+ item);
                        //休眠后删除刚添加的item, 此时可能还没有被消费
                        TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));
                        queue.remove(item);
                        System.out.println(Thread.currentThread() + "  remove : "+ item);
                    } catch (Exception e) {
                    }
                    return true;
                };
                executor.submit(call);
            } catch (Exception e) {
            }
        };

        //分布式队列测试(5个线程生产)
        System.out.println("5个并发线程生产,测试分布式队列");
        for (int i = 0; i < 5; i++) {
            putConsumer.accept(distributedIdQueue, "item"+i);
        }

        executor.shutdown();
        TimeUnit.SECONDS.sleep(3);
        distributedIdQueue.close();
        client.close();
    }
}
输出：

5个并发线程生产,测试分布式队列
Thread[pool-4-thread-2,5,main]  put : item1
Thread[pool-4-thread-5,5,main]  put : item4
Thread[pool-4-thread-4,5,main]  put : item3
Thread[pool-4-thread-3,5,main]  put : item2
Thread[pool-4-thread-1,5,main]  put : item0
message: item1
Thread[pool-4-thread-1,5,main]  remove : item0
message: item4
message: item3
message: item2
Thread[pool-4-thread-2,5,main]  remove : item1
Thread[pool-4-thread-3,5,main]  remove : item2
Thread[pool-4-thread-4,5,main]  remove : item3
Thread[pool-4-thread-5,5,main]  remove : item4

六、带优先级的分布式队列DistributedPriorityQueue

带优先级的分布式队列DistributedPriorityQueue，可指定数据优先级，优先消费值小的数据。

示例代码：

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.queue.DistributedPriorityQueue;
import org.apache.curator.framework.recipes.queue.QueueBuilder;
import org.apache.curator.framework.recipes.queue.QueueConsumer;
import org.apache.curator.framework.recipes.queue.QueueSerializer;
import org.apache.curator.framework.state.ConnectionState;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;

public class ZookeeperDistributedPriorityQueueMain {
    public static void main(String[] args) throws Exception {
        //创建zookeeper客户端
        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", new ExponentialBackoffRetry(1000, 3));
        client.start();

        //指定锁路径
        String lockPath = "/zkLockRoot/lock_21";

        //消费者
        QueueConsumer<String> queueConsumer = new QueueConsumer<String>() {
            @Override
            public void consumeMessage(String message) throws Exception {
                System.out.println("message: " + message);
            }

            @Override
            public void stateChanged(CuratorFramework client, ConnectionState newState) {

            }
        };

        //序列化
        QueueSerializer<String> queueSerializer = new QueueSerializer<String>() {
            @Override
            public byte[] serialize(String item) {
                return item.getBytes();
            }

            @Override
            public String deserialize(byte[] bytes) {
                return new String(bytes);
            }
        };

        //创建分布式队列
        QueueBuilder<String> distributedBuilder = QueueBuilder.builder(client, queueConsumer, queueSerializer, lockPath);
        DistributedPriorityQueue<String> distributedIdQueue = distributedBuilder.buildPriorityQueue(0);
        distributedIdQueue.start();

        //生成线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        //生产
        BiConsumer<DistributedPriorityQueue<String>, Integer> putConsumer = (queue, priority) -> {
            try {
                Callable<Boolean> call = () -> {
                    try {
                        queue.put("item"+priority, priority);
                        System.out.println(Thread.currentThread() + "  put : "+ "item"+priority);
                    } catch (Exception e) {
                    }
                    return true;
                };
                executor.submit(call);
            } catch (Exception e) {
            }
        };

        //分布式队列测试(5个线程生产)
        System.out.println("5个并发线程生产,测试分布式队列");
        for (int i = 0; i < 5; i++) {
            //随机指定优先级
            putConsumer.accept(distributedIdQueue, (int) (Math.random()*100));
        }

        executor.shutdown();
        TimeUnit.SECONDS.sleep(3);
        distributedIdQueue.close();
        client.close();
    }
}
输出：

5个并发线程生产,测试分布式队列
Thread[pool-4-thread-4,5,main]  put : item24
Thread[pool-4-thread-1,5,main]  put : item46
Thread[pool-4-thread-2,5,main]  put : item86
Thread[pool-4-thread-3,5,main]  put : item51
Thread[pool-4-thread-5,5,main]  put : item46
message: item24
message: item46
message: item46
message: item51
message: item86

panda-star
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ZooKeeper实现分布式FIFO队列
02-26
文章介绍了如何整合虚拟化和Hadoop，让Hadoop集群跑在VPS虚拟主机上，通过云向用户提供存储和计算的服务。现在硬件越来越便宜，一台非品牌服务器，2颗24核CPU，配48G内存，2T的硬盘，已经降到2万块人民币以下了。这种配置如果简单地放几个web应用，显然是奢侈的浪费。就算是用来实现单节点的hadoop，对计算资源浪费也是非常高的。对于这么高性能的计算机，如何有效利用计算资源，就成为成本控制的一项重要议题了。通过虚拟化技术，我们可以将一台服务器，拆分成12台VPS，每台2核CPU，4G内存，40G硬盘，并且支持资源重新分配。多么伟大的技术啊！现在我们有了12个节点的hadoop集群，让
分布式应用之zookeeper集群+消息队列Kafka
weixin_42054864的博客
09-22 378
主要原因是由于在高并发环境下，同步请求来不及处理，请求往往会发生阻塞。比如大量的请求并发访问数据库，导致行锁表锁，最后请求线程会堆积过多，从而触发 too many connection 错误，引发雪崩效应。我们使用消息队列，通过异步处理请求，从而缓解系统的压力。消息队列常应用于异步处理，流量削峰，应用解耦，消息通讯等场景。当前比较常见的 MQ 中间件有 ActiveMQ、RabbitMQ、RocketMQ、Kafka 等。
【附源码】使用 ZooKeeper 实现分布式队列、分布式锁和选举详解！
最新发布
2401_84408092的博客
04-20 839
又是一年求职季，在这里，我为各位准备了一套Java程序员精选高频面试笔试真题，来帮助大家攻下BAT的offer，题目范围从初级的Java基础到高级的分布式架构等等一系列的面试题和答案，用于给大家作为参考以下是部分内容截图《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！[外链图片转存中…(img-BZfJ7zgp-1713555963507)][外链图片转存中…(img-BBFbOlkC-1713555963508)]
Zookeeper实现分布式队列
jockerwu的博客
12-08 2094
常见的消息队列有:RabbitMQ，RocketMQ，Kafka等。Zookeeper作为一个分布式的小文件管理系统，同样能实现简单的队列功能。Zookeeper不适合存储大数据量存储，官方并不推荐作为队列使用，但由于实现简单，集群搭建较为便利，因此在一些吞吐量不高的小型系统中还是比较好用的。 本案例设立一个订单生产者，两个订单消费者，订单生产者将下单信息存入Zookeeper队列，两个消费者监听队列，共同消费订单。以此模拟下单业务，使用队列来提升订单系统的可用性及处理订单的吞吐量。 1.项目依赖 在
分布式架构之（Zookeeper原理）
qq_24872115的博客
03-05 466
Zookeeper是一个典型的分布式数据一致性的结局方案，分布式应用程序可以基于它实现注入数据发布、订阅、负载均衡、命名服务、分布式协调/通知、集群管理、Master选举、分布式锁和分布式队列等功能，顺序一致性从同一个客户端发起的事务请求，最终将会严格地按照其发起顺序被应用到Zookeeper中去原子性。
Zookeeper分布式队列实现详解
禅与计算机程序设计艺术
02-03 591
1.背景介绍 在分布式系统中，队列是一种常见的数据结构，用于在多个节点之间传递消息。然而，实现一个可靠、高效的分布式队列并不简单。这就是我们今天要讨论的主题：如何使用Zookeeper来实现一个分布式队列。 Zookeeper是一个开源的分布式服务，它为大规模分布式系统提供了一种简单且健壮的服务。它可以用于实现分布式锁、分布式队列、服务发现等功能。在这篇文章中，我们将重点讨论如何使用Zooke...
Zookeeper分布式消息队列实现详解
禅与计算机程序设计艺术
02-16 49
1. 背景介绍 1.1 分布式系统的挑战 随着互联网技术的快速发展，分布式系统已经成为了当今企业和开发者的首选架构。然而，分布式系统带来的高可用性、高性能和可扩展性的同时，也带来了诸多挑战，如数据一致性、分布式事务、服务发现等问题。为了解决这些问题，业界提出了许多解决方案，其中之一便是分布式消息队列
ZooKeeper实现分布式队列Queue
03-03
现在硬件越来越便宜，一台非品牌服务器，2颗24核CPU，配48G内存，2T的硬盘，已经降到2万块人民币以下了。这种配置如果简单地放几个web应用，显然是...ZooKeeper是一个分步式的协作系统，何为协作，ZooKeeper价值又有何
从Paxos到Zookeeper分布式一致性原理与实践PDF
01-07
《从Paxos到Zookeeper分布式一致性原理与实践》是一本深入探讨分布式系统一致性问题的著作，其中重点讲解了Paxos算法与Zookeeper在实际应用中的理论与实践。Paxos是分布式计算领域中著名的共识算法，为解决分布式...
ZooKeeper分布式过程协同技术详解_new.pdf
07-27
此外，书中还会深入探讨ZooKeeper在实际应用场景中的最佳实践，如如何利用ZooKeeper进行服务发现、实现分布式锁、构建分布式队列等。通过实例分析，读者可以更好地掌握ZooKeeper在分布式系统中的作用和价值。 在...
Zookeeper应用场景(六) 分布式队列
脑细胞:-D的博客
07-15 332
分布式队列可以简单分为两⼤类：常规的**FIFO(先⼊先出)** 队列模型，**Barrier(等待队列元素聚集后统⼀安排处理执⾏)** 模型。
Zookeeper实现分布式队列(非阻塞式)
qq_49150614的博客
05-20 427
分布式环境下，一个类似单进程队列的组件，用来实现跨进程、跨主机、跨网络的数据共享和数据传递，zookeeper可以通过顺序节点实现分布分布式队列.
Zookeeper-分布式队列
小城我家
08-04 340
Zookeeper-分布式队列 分布式队列可以简单分为2个大类： 一种常规的FIFO先入先出队列模型，还有一种等待队列元素聚集后统一安排处理执行的Barrier模型。 FIFO先入先出 FIFO -First Input First Output 先入先出，FIFO，先进入队列的请求操作先完成后，才会开始处理后面的请求 Zookeeper实现FIFO队列，和共享锁实现非常类似，FIFO队列就类似于一个全写的共享锁模型， 创建节点后， 通过调用getChildren接口来获取/queue-fifo节点下的
[Curator] Distributed Queue 的使用与分析
weixin_34227447的博客
07-04 600
为什么80%的码农都做不了架构师？>>> ...
Zookeeper 分布式锁、队列
杨宇昌的博客
04-26 2703
Zookeeper 分布式锁
Java常用开源库梳理(1)
Jack Zhou的专栏
07-06 1942
Java集合数据结构 1. List: 线程不安全：ArrayList, LinkedList, BitSet 线程安全：Vector, CopyOnWriteArrayList （1）ArrayList：使用数组实现的List，相当于动态数组，读取速度快，插入与删除速度慢（因为插入与删除时要移动后面的元素），保持插入顺序，适合于随机访问。允许重复元素，包括null。 （2）Linke...
ZooKeeper实现分布式队列、分布式锁和选举详解
am_Sun的博客
02-22 561
ZK 分布式场景
zookeeper之分布式队列
codingToMaster的博客
03-29 261
设计： 使用路径为/queue的znode下的节点表示队列中的元素。/queue下的节点都是顺序持久化的znode。这些znode名字的后缀数字表示了对应队列元素在队列中的位置。Znode名字后缀数字越小，对应队列元素在队列中的位置越靠前。 offer方法，在/queue下面创建一个顺序znode。因为znode的后缀数字是/queue下面现有znode最大后缀数字加1，所有znode对应...
zookeeper实现分布式队列
mjlfto的博客
01-22 491
zookeeper实现分布式队列 利用zookeeper的有序节点和节点一旦被删除，其他连接就不能重复删除的特性实现一个非常简单的分布式队列，说实话，我觉得用zookeeper实习分布式队列并不合适，而且我这里实现的也是最简单的，效率也不高 实现细节，利用create -s /queue/q_创建有序节点，这样数据就放到队列了，当然这一步是使用zookeeper的客户端Curator实现的，然后取...
Zookeeper分布式协调服务详解
- **分布式队列**：实现先进先出（FIFO）的队列服务。 - **集群管理**：监控和管理集群中的节点状态，如选举Master节点。 Zookeeper是一个强大的工具，它简化了分布式环境中的许多复杂问题，是构建大规模分布式系统...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值