SpringBoot整合Zookeeper客户端Curator

最新推荐文章于 2025-06-13 06:11:40 发布
最新推荐文章于 2025-06-13 06:11:40 发布
阅读量1.3k 收藏 8
点赞数
CC 4.0 BY-SA版权
分类专栏： Zookeeper 文章标签： zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40977118/article/details/124171173
本文档介绍了如何在SpringBoot项目中整合Zookeeper实现分布式锁，并利用Swagger2构建API文档。首先，展示了项目依赖的引入，包括Zookeeper、Curator和Swagger的相关库。接着，配置了Zookeeper的连接信息，并定义了Swagger的基本信息。接着，通过代码展示了创建、更新、删除Zookeeper节点的方法，以及分布式锁的使用。最后，提供了异步操作、监听和缓存监听等高级功能的实现，确保了服务的高可用性和数据一致性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1. 引入依赖

  • 这里springboot使用 2.5.4 版本，zk使用 3.7.0 版本，curator使用 5.2.1 版本

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>zookeeper-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>zookeeper-demo</name>
    <description>zookeeper-demo</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!--需要和zookeeper服务端版本保持一致-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.7.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>5.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>5.2.1</version>
        </dependency>

        <!-- Swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2. 配置文件

zookeeper.host=127.0.0.1:2181

3. Zookeeper配置文件类

package com.example.zookeeperdemo.config;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ZookeeperConfig {

    @Value("${zookeeper.host}")
    private String host;

    @Bean
    public CuratorFramework curatorFramework() {
        CuratorFramework curatorFramework = CuratorFrameworkFactory.builder()
                .connectString(host)
                .sessionTimeoutMs(5000)
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        curatorFramework.start();
        return curatorFramework;
    }

}

4. swagger配置类

package com.example.zookeeperdemo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
                .apis(RequestHandlerSelectors.basePackage("com.example")).build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder().version("1.0").build();
    }

}

5. 消息返回体

  • 用来包装返回数据
package com.example.zookeeperdemo.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class AjaxResult<T> {

    private Integer code;

    private String message;

    private T data;

    public static <T> AjaxResult<T> ok(T data) {
        return new AjaxResult<>(0, "success", data);
    }

    public static <T> AjaxResult<T> error(T data) {
        return new AjaxResult<>(1, "error", data);
    }

}

6. 创建订单service

  • 为后续测试分布式锁方法使用
package com.example.zookeeperdemo.service;

import org.springframework.stereotype.Component;

@Component
public class OrderService {

    public static Integer i = 0;

    public Integer createOrder() {
        return ++i;
    }

}

7. 创建controller

  • 包括对zk节点的常用操作，创建、更新、删除、监听及分布式锁
package com.example.zookeeperdemo.controller;

import com.alibaba.fastjson.JSONObject;
import com.example.zookeeperdemo.dto.AjaxResult;
import com.example.zookeeperdemo.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.framework.api.CuratorListener;
import org.apache.curator.framework.api.CuratorWatcher;
import org.apache.curator.framework.recipes.cache.CuratorCache;
import org.apache.curator.framework.recipes.cache.CuratorCacheListener;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.data.Stat;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

@Slf4j
@RequestMapping("/zk")
@RestController
public class ZkController {

    @Resource
    private CuratorFramework curatorFramework;

    @Resource
    private OrderService orderService;

    /**
     * 检查节点是否存在
     */
    @GetMapping("/isExistNode")
    public AjaxResult isExistNode(@RequestParam String nodeName) {
        try {
            return AjaxResult.ok(Objects.nonNull(curatorFramework.checkExists().forPath(nodeName)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 创建节点
     */
    @GetMapping("/createNode")
    public AjaxResult createNode(@RequestParam String nodeName) {
        try {
            return AjaxResult.ok(curatorFramework.create()
                    // 如果有子节点会递归创建
                    .creatingParentsIfNeeded()
                    // 设置为持久节点
                    .withMode(CreateMode.PERSISTENT).forPath(nodeName));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 更新节点数据
     */
    @GetMapping("/setNodeValue")
    public AjaxResult setNodeValue(@RequestParam String nodeName, @RequestParam String nodeValue) {
        try {
            return AjaxResult.ok(curatorFramework.setData().forPath(nodeName, nodeValue.getBytes(StandardCharsets.UTF_8)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 创建节点并设置数据
     */
    @GetMapping("/createNodeAndValue")
    public AjaxResult createNodeAndValue(@RequestParam String nodeName, @RequestParam String nodeValue) {
        try {
            return AjaxResult.ok(curatorFramework.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT)
                    .forPath(nodeName, nodeValue.getBytes(StandardCharsets.UTF_8)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 查询节点数据
     */
    @GetMapping("/queryNodeValue")
    public AjaxResult queryNodeValue(@RequestParam String nodeName) {
        try {
            return AjaxResult.ok(new String(curatorFramework.getData().storingStatIn(new Stat()).forPath(nodeName)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 查询节点下的所有子节点
     */
    @GetMapping("/queryNodeChild")
    public AjaxResult queryNodeChild(@RequestParam String nodeName) {
        try {
            return AjaxResult.ok(curatorFramework.getChildren().forPath(nodeName));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 异步执行
     */
    @GetMapping("/asyncCreateNode")
    public AjaxResult asyncCreateNode(@RequestParam String nodeName) {
        try {
            return AjaxResult.ok(curatorFramework.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT)
                    // 异步执行方法，可以设置回调方法
                    .inBackground((curatorFramework1, curatorEvent) ->
                            log.info(curatorEvent.getPath() + ":" + JSONObject.toJSONString(curatorEvent.getStat())))
                    .forPath(nodeName));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 递归删除
     */
    @GetMapping("/deleteNode")
    public AjaxResult deleteNode(@RequestParam String nodeName) {
        try {
            // guaranteed 用来保证如果删除失败，则会话有效期内一直尝试删除
            // deletingChildrenIfNeeded 表示如果有子节点，则递归删除
            return AjaxResult.ok(curatorFramework.delete().guaranteed().deletingChildrenIfNeeded().forPath(nodeName));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 单次注册监听，返回当前节点的内容信息；使用Watcher对节点进行监听，但只能监听一次；被监听的节点需要存在，否则会提示节点不存在
     */
    @GetMapping("/watchNode")
    public AjaxResult watchNode(@RequestParam String nodeName) {
        try {
            byte[] bytes = curatorFramework.getData().usingWatcher((CuratorWatcher) watchedEvent -> log
                    .info(watchedEvent.getPath() + ":" + JSONObject.toJSONString(watchedEvent))).forPath(nodeName);
            return AjaxResult.ok(new String(bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.error(null);
    }

    /**
     * 单次监听异步操作，即调用inBackground()方法会异步获得监听，同步操作则不会触发监听事件
     */
    @GetMapping("/asyncListener")
    public AjaxResult asyncListener(@RequestParam String nodeName) {
        try {
            CuratorListener curatorListener = new CuratorListener() {
                @Override
                public void eventReceived(CuratorFramework curatorFramework, CuratorEvent curatorEvent)
                        throws Exception {
                    log.info(curatorEvent.getPath() + ":" + JSONObject.toJSONString(curatorEvent));
                }
            };
            curatorFramework.getCuratorListenable().addListener(curatorListener);
            log.info(new String(curatorFramework.getData().forPath(nodeName)));
            log.info(JSONObject.toJSONString(curatorFramework.setData().forPath(nodeName, "123".getBytes())));
            // 异步操作
            curatorFramework.delete().inBackground().forPath(nodeName);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.ok(null);
    }

    /**
     * 反复注册监听，Cache事件监听可以理解为一个本地缓存视图与远程Zookeeper视图的对比过程，可以监听节点的创建，修改和删除
     */
    @GetMapping("/nodeCache")
    public AjaxResult nodeCache(@RequestParam String nodeName) {
        CuratorCache curatorCache = CuratorCache.build(curatorFramework, nodeName);
        CuratorCacheListener listener = CuratorCacheListener.builder().forNodeCache(
                        () -> log.info("nodeCache监听 " + nodeName + ":" + new String(curatorFramework.getData().forPath(nodeName))))
                .build();
        curatorCache.listenable().addListener(listener);
        curatorCache.start();
        return AjaxResult.ok(null);
    }

    /**
     * 子节点监听
     */
    @GetMapping("/childNodeCache")
    public AjaxResult childNodeCache(@RequestParam String nodeName) {
        CuratorCache curatorCache = CuratorCache.build(curatorFramework, nodeName);
        CuratorCacheListener childNodeCache = CuratorCacheListener.builder()
                .forPathChildrenCache(nodeName, curatorFramework, (curatorFramework1, pathChildrenCacheEvent) -> log
                        .info("childNodeCache监听 " + JSONObject.toJSONString(pathChildrenCacheEvent.getType())))
                .build();
        curatorCache.listenable().addListener(childNodeCache);
        curatorCache.start();
        return AjaxResult.ok(null);
    }

    /**
     * 分布式锁
     */
    @GetMapping("/lock")
    public AjaxResult lock(@RequestParam Integer count) throws Exception {
        String nodeName = "/lock";
        if (Objects.isNull(curatorFramework.checkExists().forPath(nodeName))) {
            curatorFramework.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath(nodeName);
        }
        InterProcessMutex lock = new InterProcessMutex(curatorFramework, nodeName);

        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            list.add(i);
        }
        List<Integer> collect =
            list.parallelStream().map(integer -> createOrder(lock)).sorted().collect(Collectors.toList());
        for (Integer str : collect) {
            log.info(str.toString());
        }
        return AjaxResult.ok(null);
    }

    public Integer createOrder(InterProcessMutex lock) {
        try {
            lock.acquire();
            Integer order = orderService.createOrder();
            lock.release();
            return order;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

8. 分布式锁使用

  • 分别使用InterProcessMutex的acquire和release方法，来获取和释放锁

  • 不使用分布式锁的结果，会有重复的值

在这里插入图片描述

  • 使用锁，调用100次，没有重复的值

在这里插入图片描述
在这里插入图片描述

Spring Boot(四十一)：Springboot整合ZooKeeper客户端Apache Curator基本API
u013938578的博客
02-21 1117
本文只介绍如何整合ZooKeeper，不会过多演示和讲解API，对于Zookeeper的专题介绍，请查看我的Zookeeper专栏 创建项目 1.pom.xml引入依赖 <dependency> <groupId>org.apache.curator</groupId> <artifa...
Springboot使用Curator 集成zk
南国的技术栈
03-14 5106
前言 Curator是Apache提供的一个zk的工具包，简化了 ZooKeeper 的操作。它增加了很多使用 ZooKeeper 开发的特性，可以处理 ZooKeeper 集群复杂的连接管理和重试机制。这里我们使用springboot 集成curator来操作zk。 假设你的服务已经正确添加了zk的相关依赖，Curator maveny依赖如下， <!-- curator-framework --> <dependency> <groupId>org.apach
第 5 篇 : SpringBoot整合Zookeeper框架curator
qiezi__的博客
12-24 1933
1. 在redis项目中,增加curator依赖,刷新maven <!-- Netflix的curator-recipes --> <dependency> <groupId>org.apache.curator</groupId> <artifactId>curator-recipes</artifactId> <version>5.2.0</version> </dependency> 2
【Zookeeper从入门到实战】SpringBoot整合完整指南
最新发布
weixin_41276550的博客
06-13 40
Zookeeper是一个开源的分布式协调服务，由Apache软件基金会维护。它最初是为Hadoop生态系统设计的，但现在已被广泛应用于各种分布式系统中。Zookeeper提供了一种简单而健壮的方式，用于管理分布式环境中的配置信息、命名服务、分布式同步和组服务等。本文从Zookeeper的基本概念讲起，详细介绍了安装配置、基本操作、Java客户端使用，到SpringBoot整合，再到高级应用如分布式锁、配置中心、服务注册与发现等。
SpringBoot集成Curator实现Zookeeper基本操作
pleaseprintf的博客
05-13 572
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码吧。Zookeeper是一个Apache开源的分布式的应用，为系统架构提供协调服务。从设计模式角度来审视：该组件是一个基于观察者模式设计的框架，负责存储和管理数据，接受观察者的注册，一旦数据的状态发生变化，Zookeeper就将负责通知已经在Zookeeper上注册的观察者做出相应的反应，从而实现集群中类似Master/Slave管理模式。
springboot2整合zookeeper集成curator
weixin_30314813的博客
10-06 591
步骤： 1- pom.xml <dependency> <groupId>org.apache.curator</groupId> <artifactId>curator-recipes</artifactId> <version>2.12....
Springboot-Zookeeper(curator)实现分布式锁、分布式ID等
孟孟的博客
11-06 1317
Zookeeper 的原生客户端使用起来比较繁琐，一般生成环境很少使用。curator 在外面封装了一层，使用起来更加方便，并且还提供了常用的场景，比如 leader 选举，分布式锁，分布式队列。官方文档说明：Curator 2.x.x-兼容两个zk 3.4.x 和zk 3.5.x，Curator 3.x.x-兼容兼容zk 3.5。
springboot-zookeeper-curator.rar
04-15
而Curator是Facebook贡献的Zookeeper客户端库，它对Zookeeper的API进行了封装，提供了更高级别的抽象，降低了开发人员使用Zookeeper的难度。 要将SpringBoot与Zookeeper Curator整合，首先你需要在你的项目中添加...
springboot整合zookeeper权限控制.zip
06-18
在本文中，我们将深入探讨如何在Java的Spring Boot应用中整合Zookeeper实现权限控制，特别是使用Digest方式进行身份验证。Zookeeper作为一个分布式协调服务，广泛应用于配置管理、命名服务、集群管理等多个领域。...
SpringBoot集成Zookeeper和Curator实战代码解析
描述“zookeeper的curator使用代码”明确指出压缩包包含的是关于如何在代码中使用Zookeeper客户端Curator的实践。这可能意味着该压缩包中包含了配置、代码样例、以及如何操作Zookeeper的示例，例如创建节点、读取...
springboot整合Zookeeper组件，管理架构中服务协调
06-25
Curator是Apache开源的一个Zookeeper客户端连接和操作的组件，Curator框架在Zookeeper原生API接口上进行二次包装。提供ZooKeeper各种应用场景：比如：分布式锁服务、集群领导选举、共享计数器、缓存机制、分布式队列...
ZooKeeper 实战(三) SpringBoot整合Curator-开发使用篇
AHAO的博客
01-11 3033
Curator是Apache软件基金会下的一个开源框架，目前是Apache下的顶级项目。Curator起初是 Netflix公司开源的一套ZooKeeper客户端框架，后捐献给Apache。和 ZkClient一样，它解决了非常底层的细节开发工作，包括连接、重连、反复注册Watcher的问题以及 NodeExistsException异常等。现在客户端已经配置好了，启动CuratorDemoApplication.class，观察一下是否能够正常启动。观察输出日志，显示如下信息表示客户端连接成功。
SpringBoot整合Zookeeper的Curator连接
qq_28421487的博客
08-09 777
SpringBoot整合Zookeeper的Curator连接
SpringBoot2.3整合Curator5.0实现分布式应用
liu320yj的博客
08-24 1082
概述 使用原生的zookeeper Java API开发存在一下问题： 会话连接时异步的，需要自己处理 Watch需要重复注册，否则不能生效 开发的复杂性较高 不支持多节点删除和创建，需要自己递归 Curator是一种分布式协调服务的Zookeeper的JAVA客户端库 ...
5.Spring Boot 使用 Curator 操作 ZooKeeper「第三章 ZooKeeper Java客户端」「架构之路ZooKeeper理论和实战」
悟纤学院
09-13 8542
相关历史文章（阅读本文前，您可能需要先看下之前的系列????） 国内最全的SpringBoot系列之四 享元模式：共享女友-第355篇 什么是ZooKeeper-第347篇 ZooKeeper安装-第348篇 ZooKeeper数据结构和实操-第349篇 ZooKeeper的watch机制-第350篇 ZooKeeper的acl权限控制-第351篇 ZooKeeper内存数据和持久化-第352篇 ZooKeeper集群搭建-第354篇 ZooKe...
Spring Boot(四十)：Springboot整合ZooKeeper原生客户端
u013938578的博客
02-21 1286
ZooKeeper自带客户端API介绍 ZooKeeper自带客户端的主要类是ZooKeeper类，下面介绍ZooKeeper API的使用： ZooKeeper类的构造方法如下： 从上图可知创建ZooKeeper类对象除了需要ZooKeeper服务端连接字符串(IP地址：端口)，还必须提供一个Watcher对象。Watcher是一个接口，当服务器节点花发生变化就会以事件的形式通...
zookeeper 客户端_Spring Cloud（三）：注册中心zookeeper站在客户端角度
weixin_39531834的博客
11-29 149
点击蓝字关注我们大家好，我是杰哥，前两次文章主要讲述了关于Zookeeper的服务端机制。错过的小伙伴们，可以查看杰哥的Spring Cloud专栏的前两篇推送哦那么今天，就跟着杰哥，转到客户端的角度，通过跟踪源码，进一步揭开zooKeeper的神秘面目吧~一 概况大致了解首先，通过一个图，让大家对于zookeeper的工作流有一个大概的印象1)图中 包含客户端Client、SendTh...
springboot使用zookeeper(curator)实现注册发现与负载均衡
weixin_43197042的博客
02-09 632
最简单的实现服务高可用的方法就是集群化，也就是分布式部署，但是分布式部署会带来一些问题。比如： 1、各个实例之间的协同(锁) 2、负载均衡 3、热删除 这里通过一个简单的实例来说明如何解决注册发现和负载均衡。 1、先解决依赖，这里只给出zk相关的依赖，pom.xml如下 　<dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifact
缓存架构SpringBoot集成Curator实现zookeeper分布式锁
weixin_33728268的博客
09-29 759
为什么80%的码农都做不了架构师？>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Fisher3652

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

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

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

打赏作者

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

抵扣说明：

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

余额充值