ruoyi+Hadoop+hbase实现大数据存储查询

已于 2023-11-30 20:47:00 修改
阅读量1.3k 收藏 11
点赞数 14
分类专栏： Java In Action 文章标签： 大数据 hadoop hbase
于 2023-11-30 20:46:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinacsharper/article/details/134721288
版权
文章讲述了在处理100亿条数据时，通过评估SQLServer的局限性，转向使用Hadoop和HBase解决查询效率问题，最终基于编码快速查询的场景选择了Hadoop技术。
摘要由CSDN通过智能技术生成

前言

有个现实的需求，数据量可能在100亿条左右。现有的数据库是SQL Server，随着采集的数据不断的填充，查询的效率越来越慢（现有的SQL Server查询已经需要数十秒钟的时间），看看有没有优化的方案。

考虑过SQL Server加索引、分区表、分库分表等方案，但数据量增长太快，还是很快就会遇到瓶颈，因此需要更优化的技术。在众多的NOSQL和大数据技术之下，针对此场景，主要考虑了两种方案：

  1. MongoDB：json文档型数据库，可以通过集群拓展。但更适合列比较复杂的场景快速查询。

  2. Hadoop：大数据领域的瑞士军刀，周边有很多相配套的工具可以使用，后期拓展性较强。

因为此需求只是简单的根据编码找到对应的卷号，因此最终选择Hadoop实现。

部署Hadoop

直接去官方下载，https://hadoop.apache.org/。

要注意版本的问题，版本不匹配会带来很多麻烦。我这里选择的是hadoop 3.3.4的版本。

步骤：

  1. 找到hadoop对应版本的winutils.exe、hadoop.dll文件

复制hadoop 3.3.4版本对应的winutils.exe和hadoop.dll文件到hadoop的bin文件夹下面。同步复制这两个文件，到C:\Windows\System32下面。

这两个文件可以去github上面搜索，一定要注意跟你的hadoop版本一致，否则不通过。

  1. 文件配置（下面的配置文件都在 hadoop 3.3.4/etc/hadoop 文件夹内）

a). hadoop-env.cmd文件配置

set JAVA_HOME=C:\Users\Administrator\.jdks\corretto-11.0.21

注意：这里的JAVA_HOME是指向的openjdk（开源）的版本，oracle的jdk用不起来。必须要安装openjdk。
b). core-site.xml

<configuration>
    <property> 
        <name>fs.defaultFS</name> 
        <value>hdfs://localhost:9000</value> 
    </property>
</configuration>

c). hdfs-site.xml

<configuration>
    <property> 
        <name>dfs.replication</name> 
        <value>1</value> 
    </property> 
    <property> 
        <name>dfs.namenode.name.dir</name> 
        <value>/hadoop-3.3.4/data/namenode</value> 
    </property> 
    <property> 
        <name>dfs.datanode.data.dir</name> 
        <value>/hadoop-3.3.4/data/datanode</value> 
    </property> 
</configuration>

d). yarn-site.xml

<configuration>
    <property> 
        <name>yarn.nodemanager.aux-services</name> 
        <value>mapreduce_shuffle</value> 
    </property> 
    <property> 
        <name>yarn.nodemanager.auservices.mapreduce.shuffle.class</name> 
        <value>org.apache.hadoop.mapred.ShuffleHandler</value> 
    </property> 
</configuration>
  1. 配置环境变量
    在这里插入图片描述
    再添加到Path，%HADOOP_HOME%\bin
    可以在控制台输入：hadoop version，验证是否安装配置正确
    在这里插入图片描述
    最后在控制台输入：start-all.cmd ，启动Hadoop。没有错误信息，表示Hadoop启动成功。
    在这里插入图片描述

部署Hbase

安装Hbase可以到官网下载：https://hbase.apache.org/。

同样要非常关注版本的问题，因为我上面选择的Hadoop是3.3.4，与之配套的Hbase的版本是2.5.5。

步骤：

  1. 将之前下载的winutils.exe和hadoop.dll文件拷贝到 hbase的bin目录下，比如我的：E:\hbase-2.5.5\bin。

  2. 文件配置

在hbase的conf目录下，打开hbase-site.xml文件，添加如下内容：

<configuration>
  <property>
    <name>hbase.rootdir</name>
    <value>file:///E:/hbase-2.5.5/root</value>
  </property>
  <property>
    <name>hbase.cluster.distributed</name>
    <value>false</value>
  </property>
  <property>
    <name>hbase.zookeeper.quorum</name>
    <value>127.0.0.1</value>
  </property>
  <property>
    <name>hbase.tmp.dir</name>
    <value>./tmp</value>
  </property>
  <property>
    <name>hbase.unsafe.stream.capability.enforce</name>
    <value>false</value>
  </property>
</configuration>

按照上述的配置说明，在hbase目录下，添加root和tmp文件夹。

3.配置环境变量（此处省略，参考上面的hadoop的截图）

找到hbase的bin目录下的start-hbase.cmd文件，双击启动。

hbase启动完成后的界面：
在这里插入图片描述

基于若依进行二次开发

直接引用ruoyi的项目，在里面添加功能，当然首先需要导入相应的jar包（这些jar包在hadoop和hbase里面都有，直接引用即可）。
在这里插入图片描述
当然下面还有引用的jar包，这里就不截图了，供参考。
在这里插入图片描述
该项目基于SpringBoot框架，实现了基于HDFS、hbase的基础功能。

控制器代码如下：

package com.ruoyi.web.controller.roll;

import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.roll.RollEntity;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.client.coprocessor.AggregationClient;
import org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter;
import org.apache.hadoop.hbase.filter.*;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.stereotype.Controller;
import org.springframework.util.StopWatch;
import org.springframework.web.bind.annotation.*;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.FsUrlStreamHandlerFactory;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.exceptions.DeserializationException;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.mapreduce.Job;

@Controller
@RequestMapping("/roll")
public class RollController extends BaseController {
    private String prefix = "/roll";

    /**
     * 新增角色
     */
    @GetMapping("/add")
    public String add() {
//        long count = rowCountByCoprocessor("mytb");
//        System.out.println("总记录数->>>"+count + "");
        return prefix + "/add";
    }

    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(String inputEPC) {
//        startPage();
//        List<SysRole> list = roleService.selectRoleList(role);

        //String epc = "E280117020000333BF040B34";
        //String epc = "E280119120006618A51D032D"; //查询的EPC
        String epc = inputEPC;
        String tableName = "mytb";
        String columnFamily = "mycf";

//        create(tableName, columnFamily);
//        insert(tableName,columnFamily);

        long startTime = System.currentTimeMillis();
        //E280119120006BEEA4E5032
        String reVal = query(tableName, columnFamily, epc);
        long endTime = System.currentTimeMillis();
        System.out.println("卷号查询时间为：" + (endTime - startTime) + "ms");
        RollEntity model = new RollEntity();
        model.epc = epc;
        model.rollName = reVal;
        model.searchTime = (endTime - startTime) + "ms";
        List<RollEntity> list = new ArrayList<>();
        list.add(model);
        return getDataTable(list);
    }

    // 创建表
    public static void create(String tableName, String columnFamily) {
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
        conf.set("hbase.zookeeper.quorum", "localhost");
        try {
            Connection conn = ConnectionFactory.createConnection(conf);

            if (conn.getAdmin().tableExists(TableName.valueOf(tableName))) {
                System.err.println("Table exists!");
            } else {
                HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tableName));
                try {
                    tableDesc.addFamily(new HColumnDescriptor(columnFamily));
                    conn.getAdmin().createTable(tableDesc);
                    System.err.println("Create Table SUCCESS!");
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    // 插入数据
    public static void insert(String tableName, String columnFamily) {
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
        conf.set("hbase.zookeeper.quorum", "localhost");
        try {
            Connection conn = ConnectionFactory.createConnection(conf);

            TableName tn = TableName.valueOf(tableName);
            Table table = conn.getTable(tn);
            try {

//                for (int i = 17742000; i <= 100000000; i++) {
//                    Put put = new Put(Bytes.toBytes("row" + i));
//                    put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes("code"),
//                            Bytes.toBytes("E280119120006BEEA4E5032" + i));
//                    table.put(put);
//                }

//                Put put = new Put(Bytes.toBytes("E280119120006618A51D032D"));
//                put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes("code"),
//                            Bytes.toBytes("CQ-230308009"));
//                table.put(put);

                Put put = new Put(Bytes.toBytes("E280117020000333BF040B34"));
                put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes("code"),
                        Bytes.toBytes("CQ-230309002"));
                table.put(put);


                table.close();// 释放资源
                System.err.println("record insert SUCCESS!");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    // 查询
    public static String query(String tableName, String columnFamily, String rowName) {

        String reVal = "";

        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
        conf.set("hbase.zookeeper.quorum", "localhost");
        try {
            Connection conn = ConnectionFactory.createConnection(conf);

            TableName tn = TableName.valueOf(tableName);
            Table table = conn.getTable(tn);
            try {
                Get get = new Get(rowName.getBytes());
                Result r = table.get(get);
                for (Cell cell : r.rawCells()) {
                    String family = new String(CellUtil.cloneFamily(cell));

                    String qualifier = new String(CellUtil.cloneQualifier(cell));
                    String value = new String(CellUtil.cloneValue(cell));
                    System.out.println("列:" + family + ":" + qualifier + " 值:" + value);
                    reVal = value;
                    break;
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                conn.close();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return reVal;
    }

    //过滤查询
    public static void queryFilter(String tableName, String columnFamily, String rowName, String value) {
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
        conf.set("hbase.zookeeper.quorum", "localhost");

        try {
            Connection conn = ConnectionFactory.createConnection(conf);

            TableName tn = TableName.valueOf(tableName);
            Table table = conn.getTable(tn);
            try {
                Scan scan = new Scan();
                Filter filter = new ValueFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes(value)));
                scan.setFilter(filter);
                ResultScanner rs = table.getScanner(scan);
                for (Result res : rs) {
                    System.out.println(res);
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    //读取HDFS文件
    private static void readHDFSFileContents() {

        InputStream is = null;
        OutputStream os = null;
        BufferedInputStream bufferInput = null;
        BufferedOutputStream bufferOutput = null;
        try {
            is = new URL("hdfs://127.0.0.1:9000/myHadoop/1.txt").openStream();
            bufferInput = new BufferedInputStream(is);
            // IOUtils.copyBytes(is, os, 4096,false);

            byte[] contents = new byte[1024];

            int bytesRead = 0;
            String strFileContents = "";
            while ((bytesRead = is.read(contents)) != -1) {
                strFileContents += new String(contents, 0, bytesRead);
            }
            System.out.println(strFileContents);

        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            // IOUtils.closeStream(is);
        }
    }

    //创建HDFS目录
    private static void createHDFSDirectory() {
        // TODO Auto-generated method stub
        try {
            Configuration conf = new Configuration();
            conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");
            FileSystem fs = FileSystem.get(conf);
            boolean result = fs.mkdirs(new Path("/myHadoop"));
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //查询Hbase有多少条记录
    public long rowCountByCoprocessor(String tablename){
        long count = 0;
        try {
            Configuration conf = HBaseConfiguration.create();
            conf.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
            conf.set("hbase.zookeeper.quorum", "localhost");

            Connection connection = ConnectionFactory.createConnection(conf);
            //提前创建connection和conf
            Admin admin = connection.getAdmin();
            //admin.enableTable(TableName.valueOf("mytb"));
            TableName name=TableName.valueOf(tablename);
            //先disable表，添加协处理器后再enable表
            //admin.disableTable(name);
            HTableDescriptor descriptor = new HTableDescriptor(name); //admin.getTableDescriptor(name);
            //descriptor.setReadOnly(false);
            String coprocessorClass = "org.apache.hadoop.hbase.coprocessor.AggregateImplementation";
            if (! descriptor.hasCoprocessor(coprocessorClass)) {
                descriptor.addCoprocessor(coprocessorClass);
            }
            //admin.modifyTable(name, descriptor);
            //admin.enableTable(name);

            //计时
            StopWatch stopWatch = new StopWatch();
            stopWatch.start();

            Scan scan = new Scan();
            AggregationClient aggregationClient = new AggregationClient(conf);

            //System.out.println("RowCount: " + aggregationClient.rowCount(name, new LongColumnInterpreter(), scan));

            count = aggregationClient.rowCount(name, new LongColumnInterpreter(), scan);
            stopWatch.stop();
            System.out.println("统计耗时：" +stopWatch.getTotalTimeMillis());
            connection.close();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return count;
    }
}

最终效果

在这里插入图片描述

纯手动搭建大数据集群架构_记录017_为RuoYi-Cloud-Plus-master添加phoenix-jdbc支持_用mybatis操作hbase---大数据之Hadoop3.x工作笔记0178
添柴程序猿的专栏
03-30 371
首先在ruoyi-demo中,我们这里,配置一下数据源,原来的数据源master是mysql的这里我改成了phoenix,因为,我想在这里面,以后就操作hbase数据库了,不配置多数据源了,多数据源需要使用的时候切换数据源比较麻烦.然后接下来我就可以进行业务操作了,权限很简单不用说,然后就是把大量数据通过,springboot接口,发送到kafka中去,然后从kafka中获取数据以后,然后把数据存入到hbase中去.开始的时候,要保证,hbase集群已经安装完了,phoenix客户端也已经安装完了,然后。
HBase与Hadoop：HBase与Hadoop的集成与使用
AI天才研究院
01-21 1407
1.背景介绍 1. 背景介绍 HBase是一个分布式、可扩展、高性能的列式存储系统，基于Google的Bigtable设计。HBase提供了一种自动分区、自动同步的数据存储方式，可以存储大量数据，并提供快速的读写访问。Hadoop是一个分布式文件系统，可以存储和处理大量数据。HBase与Hadoop的集成可以实现数据的高效存储和处理。 在大数据时代，数据的存储和处理需求不断增加，传统的关系型...
若依框架---PageHelper分页(十)
02-05 3542
若依框架就是一个后台管理框架---PageHelper分页
RuoYi 集成H2数据库
我的博客
03-31 365
yml文件配置 spring下配置。依赖（Dependencies）
若依(ruoyi)整合多数据源MySQL+Phoenix
BQ Blog
05-16 1092
在对若依二开过程中，有多数据源需求，使用MySQL存储系统信息，Phoenix连接Hbase存储资源信息，于是有了以下解决方案。
第八章HBase组件安装配置
liupeizhu的博客
12-16 220
HBase介绍
qq_35932990的博客
01-30 1564
本文介绍了HBase是什么；HBase的优缺点、数据模型；HBase的架构设计；HBase的命令以及使用注意事项。
基于Ruoyi+uniapp的学生考勤系统设计源码
04-04
本设计源码提供了一个基于Ruoyi和uniapp的学生考勤系统。项目包含1016个文件，主要使用Java、Vue、JavaScript、HTML和Shell编程语言。文件类型包括309个Java类文件、290个Java源代码文件、102个Vue组件文件、87个SVG...
基于Ruoyi+uniapp实现学生考勤系统 学生考勤源码+项目说明.zip
最新发布
05-22
内置功能 用户管理：用户是系统操作者，该功能主要完成系统用户配置。 部门管理：配置系统组织机构（公司、部门、小组），树结构展现支持数据权限。 岗位管理：配置系统用户所属担任职务。 菜单管理：配置系统菜单，...
基于Ruoyi+uniapp实现学生考勤系统源码+项目说明（学生考勤（普通、位置、二维码签到）等其他模块功能）.zip
02-21
基于Ruoyi+uniapp实现学生考勤系统源码+项目说明（学生考勤（普通、位置、二维码签到）等其他模块功能）.zip基于Ruoyi+uniapp实现学生考勤系统源码+项目说明（学生考勤（普通、位置、二维码签到）等其他模块功能）....
ruoyi-common_若依核心模块代码_
09-30
若依核心模块代码
基于RuoYi+Vue开发的药品进销存管理系统源码+数据库
12-19
基于RuoYi+Vue开发的药品进销存管理系统源码+数据库.zip 95分以上高分课程设计、期末大作业项目。 基于RuoYi+Vue开发的药品进销存管理系统源码+数据库.zip 95分以上高分课程设计、期末大作业项目。基于RuoYi+Vue...
集成Hadoop：HBase与Hadoop的集成和应用
AI天才研究院
01-21 941
1.背景介绍 1. 背景介绍 Hadoop是一个开源的分布式存储和分析框架，它可以处理大量数据并提供快速的查询和分析能力。HBase是一个分布式、可扩展、高性能的列式存储系统，它基于Google的Bigtable设计，可以与Hadoop集成使用。在本文中，我们将讨论HBase与Hadoop的集成和应用，以及其在实际应用场景中的优势和挑战。 2. 核心概念与联系 2.1 Hadoop的核心组...
【学习】若依源码（前后端分离版）之 “ 分页以及查询的功能实现”
qq_44386537的博客
08-04 5371
分页处理一方面可以提高我们浏览数据的效率，符合我们浏览者的心理，减少了大量数据存在的杂乱问题；同时分页技术也可以降低带宽使用，提高访问速度。这次一起来学习ruoyi的分页功能实现
hbase安装包_开源工具 | HBase表管理系统——HBaseManager2.0.2
weixin_39559119的博客
11-23 499
1. 前言在之前的文章中已经为大家简单介绍过HBaseManager，它提供界面化的方式来帮助我们有效地管理我们集群的HBase表信息。在HBase的维护工作中，绝大多数需要在HBase Shell下执行的命令，都可以选择在系统中完成。HBaseManager部署方便，一键启动，界面美观大方，功能流畅友好，绝对能成为你HBase运维工作中的一大助力。经过近一个月的开发迭代与BUG修复，系...
Nodejs+Express+MongoDB重构若依管理系统后端框架（二）
JavaScript_ZJH的博客
09-28 1835
前言 昨天已经大致介绍了后端的大体框架，今天来说一下如何将这个项目改的较为工程化一些，方便我们去开发。昨天的内容相对简单，只有入口文件和数据库两个最为重要的模块。今天将结合前端一起为大家梳理一下。前端项目就不说了，大家可以去若依官网去下载前后端分离的若依前端框架。 一、项目的结构 以上就是项目的一级目录，展开内容将会在开发过程中详细讲解。 二、路由管理（routes文件夹） 后端开发的主要内容就是给前端提供接口，前端通过axios发送网络请求，后端接到请求后操作数据库，返回前端需要的数据。同时，前端在请求前
集成Kafka：HBase与Kafka的集成和应用
AI天才研究院
01-21 1115
1.背景介绍 在大数据时代，数据处理和分析的需求日益增长。为了更高效地处理和分析大量数据，许多企业和组织采用了分布式系统。HBase和Kafka是两个非常重要的分布式系统，它们在数据存储和流处理方面具有很高的性能和可扩展性。为了更好地利用这两个系统的优势，需要将它们集成在一起。本文将详细介绍HBase与Kafka的集成和应用，包括背景介绍、核心概念与联系、核心算法原理和具体操作步骤、数学模型公式...
Kafka将数据写入到HBase案例
wanjialin的博客
01-03 2089
准备工作： 1、创建表 启动Hbase，命令start-hbase.sh。 在Hbase中，创建一个命名空间，并创建一张表。 命名空间create_namespace 'events_db' train表create 'events_db:train','eu' 2、源数据的处理 通过flume将日志数据写入到Kafka的主题中。 操作链接 操作步骤： 分为4大模块，handler、worker、writer和test测试模块 1、handler模块：返回一个Put类型的集合 接口： public inte
若依笔记（三）：用户权限体系与数据隔离
叶子叶来
11-02 3760
​ 已知若依单体的前端采用vue-element-admin，在前端的专栏系列vue-element-admin的动态路由已详细拆解，其最大特点是使用后端返回数据控制前端菜单，每次接口请求前会有路由拦截来获取权限和菜单列表并重新渲染页面，配合若依后端自己实现的数据权限切面，能够实现很好地的数据隔离和权限隔离，那么现在就从代码层面分析其实现； ​
学生考勤系统开发：Ruoyi+uniapp的应用与实现
3. 学生考勤系统实现：学习如何基于Ruoyi框架和uniapp技术实现学生考勤系统，这涉及到考勤数据的录入、查询、管理等后端逻辑，以及通过uniapp构建的前端展示和用户交互界面。 4. 模块化功能开发：了解如何在系统中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

全栈极简

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

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

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

打赏作者

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

抵扣说明：

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

余额充值