hbase命令实践与java api代码实践

最新推荐文章于 2023-01-18 17:00:00 发布
最新推荐文章于 2023-01-18 17:00:00 发布
阅读量745 收藏
点赞数
文章标签： hbase hbaseshell hbase-api hbase-java HBaseCli
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyh9459/article/details/69218457
版权

命名空间（namespace）： 默认为default命名空间
list_namespace
create_namespace ‘my_ns’
create ‘my_ns:my_table’,’fam’
exists ‘my_ns:my_table’
list
list_namespace
disable ‘my_ns:my_table’
drop ‘my_ns:my_table’
drop_namespace ‘my_ns’

rowkey与family： rowkey行键唯一，family列簇，每一个数据项都有时间戳
put ‘my_ns:my_table’,’rowkey1’,’fam:f1’,’r1f1’
put ‘my_ns:my_table’,’rowkey1’,’fam:f2’,’r1f2’
put ‘my_ns:my_table’,’rowkey1’,’fam:f3’,’r1f3’
put ‘my_ns:my_table’,’rowkey2’,’fam:f1’,’r2f1’
put ‘my_ns:my_table’,’rowkey2’,’fam:f2’,’r2f2’
put ‘my_ns:my_table’,’rowkey2’,’fam:f3’,’r2f3’
put ‘my_ns:my_table’,’rowkey3’,’fam:f1’,’r3f1’
put ‘my_ns:my_table’,’rowkey3’,’fam:f2’,’r3f2’
put ‘my_ns:my_table’,’rowkey3’,’fam:f3’,’r3f3’
list ‘my_ns:my_table’
scan ‘my_ns:my_table’
get ‘my_ns:my_table’,’rowkey1’
get ‘my_ns:my_table’,’rowkey1’,’fam’
get ‘my_ns:my_table’,’rowkey1’,’fam:f1’
delete ‘my_ns:my_table’,’rowkey1’,’fam:f1’
delete ‘my_ns:my_table’,’rowkey2’,’fam:f2’
delete ‘my_ns:my_table’,’rowkey3’,’fam:f3’
scan ‘my_ns:my_table’

hbase java api：

官方API文档：http://hbase.apache.org/devapidocs/index.html

步骤一：关闭hbase机器上的防火墙，确保在本地能与远程hbase建立tcp连接：service iptable stop

步骤二： maven项目中添加依赖

<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>1.3.0</version>
</dependency>

注意：有个小问题，jdk1.6的tools.jar自动下载不到，得自己手动去下个包把依赖写上，hbase-client里面依赖了这个包，如下

<dependency>
    <groupId>jdk.tools</groupId>
    <artifactId>jdk.tools</artifactId>
    <version>1.6</version>
    <scope>system</scope>
    <systemPath>E:/downloads/jar/tools.jar</systemPath>
</dependency>

步骤三：本地机器需要加上hbase服务器hostname的ip映射，我在hosts文件里添加了如下一行：
192.168.137.10 centos001

步骤四： 编写HBaseClient类与测试（hbase单机版安装：http://blog.csdn.net/wyh9459/article/details/69053599）

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseClient {

    private Configuration configuration;
    private Connection connection;
    private Admin admin;

    private static HBaseClient instance;

    private HBaseClient() throws IOException{
        configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum", 
                "192.168.137.10:2181,192.168.137.10:2182,192.168.137.10:2183");
        connection = ConnectionFactory.createConnection(configuration);
        admin = connection.getAdmin();
    };

    public static HBaseClient getInstance() throws IOException{
        if(instance==null){
            synchronized (HBaseClient.class) {
                if(instance==null){
                    instance = new HBaseClient();
                }
            }
        }
        return instance;
    }

    public void close() throws IOException{
        if(admin!=null){
            admin.close();
        }
        if(connection!=null){
            connection.close();
        }
    }

    /**
     * 判断命名空间是否存在
     * @param strNamespace 命名空间
     * @return true-存在,false-不存在
     * @throws IOException
     */
    public boolean isExistsNamespace(String strNamespace) throws IOException{
        NamespaceDescriptor[] namespaces = admin.listNamespaceDescriptors();
        for(int i=0; i<namespaces.length; i++){
            if(strNamespace.equals(namespaces[i].getName())){
                return true;
            }
        }
        return false;
    }

    /**
     * 创建命名空间
     * @param strNamespace 命名空间
     * @return true-创建成功,false-存在该namespace
     * @throws IOException
     */
    public boolean createNamespace(String strNamespace) throws IOException{
        if(isExistsNamespace(strNamespace)){
            return false;
        }else{
            admin.createNamespace(NamespaceDescriptor.create(strNamespace).build());
            return true;
        }
    }

    /**
     * 判断表是否存在
     * @param strTableName 表名
     * @return true-存在,false-不存在
     * @throws IOException
     */
    public boolean isExistsTable(String strTableName) throws IOException{
        TableName tableName = TableName.valueOf(strTableName);
        return admin.tableExists(tableName);
    }

    /**
     * 创建表，存在同名表时不删除同名表也不新建表
     * @param strTableName 表名
     * @param strFamily 列簇名
     * @return true-成功创建，false-已存在同名表，未新建表
     * @throws IOException
     */
    public boolean createTable(String strTableName, String strFamily) throws IOException {
        TableName tableName = TableName.valueOf(strTableName);
        if (admin.tableExists(tableName)) {
            return false;
        }
        HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
        HColumnDescriptor family = new HColumnDescriptor(strFamily);
        hTableDescriptor.addFamily(family);
        admin.createTable(hTableDescriptor);
        return true;
    }

    /**
     * 创建表，存在同名表时删除同名表然后新建表
     * @param strTableName 表名
     * @param strFamily 列簇名
     * @return 表创建完成后返回true
     * @throws IOException
     */
    public boolean createTableForced(String strTableName, String strFamily) throws IOException {
        TableName tableName = TableName.valueOf(strTableName);
        if (admin.tableExists(tableName)) {
            deleteTable(strTableName);
        }
        HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
        HColumnDescriptor family = new HColumnDescriptor(strFamily);
        hTableDescriptor.addFamily(family);
        admin.createTable(hTableDescriptor);
        return true;
    }

    /**
     * 插入数据
     * @param strTableName 表名
     * @param put 插入数据对象
     * @throws IOException
     */
    public void insertData(String strTableName, Put put) throws IOException {
        Table table = connection.getTable(TableName.valueOf(strTableName));
        table.put(put);
    }

    /**
     * 插入数据
     * @param strTableName 表名
     * @param putList 插入数据对象集合
     * @throws IOException
     */
    public void insertData(String strTableName, List<Put> putList) throws IOException {
        Table table = connection.getTable(TableName.valueOf(strTableName));
        table.put(putList);
    }

    /**
     * 扫描表
     * @param strTableName 表名
     * @return ResultScanner 扫描结果对象
     * @throws IOException
     */
    public ResultScanner queryTable(String strTableName) throws IOException {
        Table table = connection.getTable(TableName.valueOf(strTableName));
        ResultScanner scanner = table.getScanner(new Scan());
        return scanner;
    }

    /**
     * 获取指定行的数据
     * @param strTableName 表名
     * @param get 查询条件对象
     * @return 查询结果对象
     * @throws IOException
     */
    public Result queryTableByRowKey(String strTableName, Get get) throws IOException {
        Table table = connection.getTable(TableName.valueOf(strTableName));
        Result result = table.get(get);
        return result;
    }

    /**
     * 根据Filter条件对象扫描表
     * @param strTableName 表名
     * @param filter Filter条件对象
     * @return 扫描结果对象
     * @throws IOException
     */
    public ResultScanner queryTableByFilter(String strTableName, Filter filter) throws IOException {
        Table table = connection.getTable(TableName.valueOf(strTableName));
        Scan scan = new Scan();
        scan.setFilter(filter);
        ResultScanner scanner = table.getScanner(scan);
        return scanner;
    }

    /**
     * 根据Filter条件对象列表扫描表
     * @param strTableName 表名
     * @param filters Filter条件对象集合
     * @return 扫描结果集合
     * @throws IOException
     */
    public ResultScanner queryTableByFilters(String strTableName, List<Filter> filters) throws IOException {
        Table table = connection.getTable(TableName.valueOf(strTableName));
        FilterList filterList = new FilterList(filters);
        Scan scan = new Scan();
        scan.setFilter(filterList);
        ResultScanner scanner = table.getScanner(scan);
        return scanner;
    }

    /**
     * 添加列
     * @param strTableName 表名
     * @param strColumn 列簇名
     * @throws IOException
     */
    public void addColumn(String strTableName, String strColumn) throws IOException {
        TableName tableName = TableName.valueOf(strTableName);
        HColumnDescriptor columnDescriptor = new HColumnDescriptor(strColumn);
        admin.addColumn(tableName, columnDescriptor);
    }

    /**
     * 删除列
     * @param strTableName 表名
     * @param strColumn 列簇名
     * @throws IOException
     */
    public void deleteColumn(String strTableName, String strColumn) throws IOException {
        TableName tableName = TableName.valueOf(strTableName);
        admin.deleteColumn(tableName, strColumn.getBytes());
    }

    /**
     * 根据rowkey删除行
     * @param strTableName 表名
     * @param rowkey 行名
     * @throws IOException
     */
    public void deleteByRowKey(String strTableName, String rowkey) throws IOException {
        Table table = connection.getTable(TableName.valueOf(strTableName));
        Delete delete = new Delete(Bytes.toBytes(rowkey));
        table.delete(delete);
    }

    /**
     * 删除行
     * @param strTableName 表名
     * @param list 删除数据集合
     * @throws IOException
     */
    public void deleteRow(String strTableName, List<Delete> list) throws IOException {
        Table table = connection.getTable(TableName.valueOf(strTableName));
        table.delete(list);
    }

    /**
     * 根据Filter条件对象删除行
     * @param strTableName 表名
     * @param filter Filter条件对象
     * @throws IOException
     */
    public void deleteByFilter(String strTableName, Filter filter) throws IOException {
        ResultScanner scanner = queryTableByFilter(strTableName, filter);
        List<Delete> list = new ArrayList<Delete>();
        for (Result result : scanner) {
            Delete delete = new Delete(result.getRow());
            list.add(delete);
        }
        deleteRow(strTableName, list);
        scanner.close();
    }

    /**
     * 截断表
     * @param strTableName 表名
     * @throws IOException
     */
    public void truncateTable(String strTableName) throws IOException {
        TableName tableName = TableName.valueOf(strTableName);
        admin.disableTable(tableName);
        admin.truncateTable(tableName, true);
    }

    /**
     * 删除表
     * @param strTableName 表名
     * @throws IOException
     */
    public void deleteTable(String strTableName) throws IOException {
        TableName tableName = TableName.valueOf(strTableName);
        admin.disableTable(tableName);
        admin.deleteTable(tableName);
    }

    public static void main(String[] args) throws IOException {
        HBaseClient test = HBaseClient.getInstance();
        test.testCreateNamespace();
        test.testCreateTable();
        test.testInsertData();
        test.testQuery();
        test.testQueryByRow();
        test.testQueryByFilter();
        test.testQueryByFilters();
        test.testAddColumn();
        test.testDeleteColumn();
        test.testDeleteRow();
        test.testDeleteTable();
        test.close();
    }

    public void testCreateNamespace() throws IOException{
        createNamespace("ns1");
    }

    public void testCreateTable() throws IOException{
        createTableForced("ns1:t1", "cf");
    }

    public void testInsertData() throws IOException {
        List<Put> putList = new ArrayList<Put>();
        Put put = null;
        for (int i = 0; i < 10; i++) {
            put = new Put(Bytes.toBytes("row" + i));
            put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("c1"), Bytes.toBytes("r" + i + "c1"));
            put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("c2"), Bytes.toBytes("r" + i + "c2"));
            putList.add(put);
        }
        insertData("ns1:t1", putList);
    }

    public void testQuery() throws IOException{
        ResultScanner scanner = queryTable("ns1:t1");
        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("row key is:" + new String(row));
            List<Cell> listCells = result.listCells();
            for (Cell cell : listCells) {
                byte[] familyArray = cell.getFamilyArray();
                byte[] qualifierArray = cell.getQualifierArray();
                byte[] valueArray = cell.getValueArray();
                System.out.println("row value is:" + new String(familyArray)
                        + new String(qualifierArray) + new String(valueArray));
            }
        }
        scanner.close();
    }

    public void testQueryByRow() throws IOException{
        Get get = new Get("row5".getBytes());
        Result result = queryTableByRowKey("ns1:t1", get);
        byte[] row = result.getRow();
        System.out.println("row key is:" + new String(row));
        List<Cell> listCells = result.listCells();
        for (Cell cell : listCells) {
            byte[] familyArray = cell.getFamilyArray();
            byte[] qualifierArray = cell.getQualifierArray();
            byte[] valueArray = cell.getValueArray();
            System.out.println("row value is:" + new String(familyArray)
                    + new String(qualifierArray) + new String(valueArray));
        }
    }

    public void testQueryByFilter() throws IOException{
        Filter filter = new SingleColumnValueFilter(
                Bytes.toBytes("cf"), Bytes.toBytes("c1"),
                CompareOp.EQUAL, Bytes.toBytes("r3c1"));
        ResultScanner scanner = queryTableByFilter("ns1:t1", filter);
        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("row key is:" + new String(row));
            List<Cell> listCells = result.listCells();
            for (Cell cell : listCells) {
                byte[] familyArray = cell.getFamilyArray();
                byte[] qualifierArray = cell.getQualifierArray();
                byte[] valueArray = cell.getValueArray();
                System.out.println("row value is:" + new String(familyArray)
                        + new String(qualifierArray) + new String(valueArray));
            }
        }
        scanner.close();
    }

    public void testQueryByFilters() throws IOException{
        List<Filter> filters = new ArrayList<Filter>();
        Filter filter1 = new SingleColumnValueFilter(
                Bytes.toBytes("cf"), Bytes.toBytes("c1"),
                CompareOp.EQUAL, Bytes.toBytes("r5c1"));
        Filter filter2 = new SingleColumnValueFilter(
                Bytes.toBytes("cf"), Bytes.toBytes("c2"),
                CompareOp.EQUAL, Bytes.toBytes("r5c2"));
        filters.add(filter1);
        filters.add(filter2);
        ResultScanner scanner = queryTableByFilters("ns1:t1", filters);
        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("row key is:" + new String(row));
            List<Cell> listCells = result.listCells();
            for (Cell cell : listCells) {
                byte[] familyArray = cell.getFamilyArray();
                byte[] qualifierArray = cell.getQualifierArray();
                byte[] valueArray = cell.getValueArray();
                System.out.println("row value is:" + new String(familyArray)
                        + new String(qualifierArray, "UTF-8") + new String(valueArray, "UTF-8"));
            }
        }
        scanner.close();
    }

    public void testAddColumn() throws IOException{
        addColumn("ns1:t1", "fam");
        testQueryByRow();
    }

    public void testDeleteColumn() throws IOException{
        deleteColumn("ns1:t1", "fam");
        testQueryByRow();
    }

    public void testDeleteRow() throws IOException{
        List<Delete> list = new ArrayList<Delete>();
        Delete delete = new Delete(Bytes.toBytes("row4"));
        list.add(delete);
        deleteRow("ns1:t1",list);
        testQuery();
    }

    public void testDeleteTable() throws IOException{
        truncateTable("ns1:t1");
        testQuery();
        deleteTable("ns1:t1");
        System.out.println(admin.tableExists(TableName.valueOf("ns1:t1")));
    }

}
Amolu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hbase-client-1.4.3-API文档-中文版.zip
04-23
赠送jar包：hbase-client-1.4.3.jar； 赠送原API文档：hbase-client-1.4.3-javadoc.jar； 赠送源代码：hbase-client-1.4.3-sources.jar； 赠送Maven依赖信息文件：hbase-client-1.4.3.pom； 包含翻译后的API文档：hbase-client-1.4.3-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.apache.hbase:hbase-client:1.4.3； 标签：apache、client、hbase、jar包、java、API文档、中文版； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
hbase的api操作
u013111855的博客
03-08 2246
hbase的api操作TestHbaseConnectionTestHbaseDDLTestHbaseDMLTestHbaseFilter总结 TestHbaseConnection 两大对象： HbaseConfiguration： hbase的加载配置文件的对象，用于加载默认配置文件 hbase-dafult.xml Connection： hbase的连接对象 package hba...
HBase：使用Java操作HBase（1）之namespace的操作
编程学习者的博客
06-15 2557
1.声明 当前内容主要用于本人学习和复习，当前的内容主要为使用java方式操作HBase中的namespace 当前的操作基于前面的博文：开放HBase让java可以访问 2.开始操作 import java.io.IOException; import java.util.Arrays; import java.util.List; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfig
HBase API 创建表
qq_59947103的博客
04-05 3535
1.配置文件和连接信息 // 两个变量的声明： private static Connection connection = null; private static Admin admin = null; static{ try { // 1.获取配置文件信息 Configuration configuration = HBaseConfiguration.create();
Hbase入门之三HBase Client API使用入门1
云智禅师的专栏
11-28 2753
Hbase的基本介绍 　　今天公司进行了一样关于Hbase的培训，让我对Hbase有了基础的了解。和大家分享一样。自己的理解不是很深，如果有说的不对地方，希望大家斧正。 　　什么是Hbase？ 　　HBase是一个分布式的、面向列的开源数据库。 　　分布式：Hbase的分布式是依托于Hadoop的，那Hadoop又是什么？Hadoop 是一个能够对大量数据进行分布式处理的软
HBase JavaAPI开发
06-21
使用JavaAPI实现HBase的ddl（创建表、删除表、修改表（添加列族等））、dml（添加数据、删除数据）、dql（查询数据（get、scan））等操作 除此之外还包含一些其他操作：命名空间的应用、快照的应用等 对应（《HBase...
11-HBase Java API编程实践1
08-08
11-HBase Java API编程实践1
hbase访问方式之java api
08-29
主要介绍了hbase访问方式之java api,需要的朋友可以参考下
HBase与MapReduce处理操作（基于JavaAPI）
05-30
该案例中主要使用MapReduce作为处理组件进行数据处理，实现的案例有如通过javaapi实现hbase数据写入hdfs、hbase表数据复制到另一个表中等操作 对应（《HBase分布式存储系统应用》胡鑫喆 张志刚著）教材中案例
hbase的java客户端api操作示例代码.zip
最新发布
11-03
hbase的java客户端api操作示例代码
HBase之 java 客户端创建 namespace 和 table 操作(5)
桂林算啦粉的博客
08-29 921
1 Hbase的java客户端入门程序 /** * description : 使用java客户端操作 hbase * 1)zookeeper上记录着hbase集群的信息 * 2)获取hbase的连接对象 * 3)建表 建namespace 修改表结构.. 对数据的操作.. get put delete * 4) admin 管理者 建namespace 建表 表结构 删除表/名称空间 工具 合并切割移动 刷写 * 5) table 表对象 对数据操作 put dele
Hbase Client API 介绍
专注大数据技术以及行业解决方案
12-24 607
Hbase API 常用类应用 网上Hbase的介绍有很多，案例也不少。自己写了个Demo，进行一些简单的总结。 HBase 常用类介绍。 JAVA API 和 HBase数据库模型之间的关系 JAVA 类 Hbase 数据模型 HBaseAdmin 数据库(database) HBaseConfiguration HTable 表(table) HTableDescri...
HBASE API 操作
hj1993的博客
01-18 1542
1、idea创建一个maven项目2、添加相关依赖（HBASE客户端（最主要）、服务端），pom.xml
HBaseclientAPI基本操作
weixin_33896069的博客
08-09 167
Java类与HBase数据模型 HBaseConfiguration 包名 ： org.apache.hadoop.hbase.HBaseConfiguration 作用：对HBase进行配置。 使用方法演示样例： HBaseConfiguration hconfig = new HBaseConfiguration(); hconfig.set("hbase...
五十二、HBase的API操作
象在舞的技术专栏
03-19 1338
前几篇文章我们介绍了HBase的原理以及安装部署、命令行操作等知识，本文我们来看一下HBase的API操作。关注专栏《破茧成蝶——大数据篇》，查看更多相关的内容~ 目录 一、环境准备 二、HBaseAPI操作 2.1获取HBase连接对象 2.2判断命名空间是否存在 2.3判断HBase中是否存在某张表 2.4创建表 2.5操作表 2.6删除表 2.7删除表数据 三、完整代码 一、环境准备 首先需要新建工程并导入相关的依赖，如下所示： <de...
HBase Java API: hbase-client
热门推荐
人不风流枉少年
03-12 1万+
一：简介 hbase-client 是hbase的api 二：API package org.apache.hadoop.hbase.client; public class ConnectionFactory { /* * 创建连接 * @param conf hbase属性配置 */ public static Connection createConnection(Configu...
HBase_HBase2.0 Java API 操作指南 （一）CRUD
迎难而上
04-21 1262
由于网上的HBase Java API 大多都是基于 Hbase 1.0 + 的，故写了这篇文章。 参考了以下文章： https://blog.csdn.net/u012893747/article/details/84753988 本篇文章只讲解下 基本的 CURD 操作，更为复杂的操作，我们放到后面讲解。 目录 依赖包 建立连接 创建表 删除列族 删除表 插入数据 ...
hbase java操作api - nameSpace，表，列族，列的操作 代码示例
小哇
09-13 2514
代码示例 有很多的代码是重复的，只是为形成记忆，见谅， 另外需要将 hbase-site.xml,hdfs-site.xml,core-site.xml三个文件放到Resources上目录中 import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.*; import org.apache.hadoop.hbase.client.*; import org.apache.hadoop.hbase.client
hbase java api 查询_java api 查询hbase
05-27
首先，您需要在 Java 代码中导入 HBase 的相关类，这些类通常在 HBase 的 Java API 中提供。然后，您可以使用以下步骤来查询 HBase 数据： 1. 创建 HBaseConfiguration 实例并设置 HBase 的配置信息： ```java ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值