Java操作HbaseAPI大全（增删改查等操作）

最新推荐文章于 2023-05-04 14:41:06 发布
最新推荐文章于 2023-05-04 14:41:06 发布
阅读量3k 收藏 6
点赞数 2
分类专栏： java 文章标签： hbase java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guihua55/article/details/112634205
版权

博主直接放代码，需要的小伙伴自行选择学习哈

maven为：

<dependency>

    <groupId>org.apache.hbase</groupId>

    <artifactId>hbase-client</artifactId>

    <version>1.4.13</version>

</dependency>

import org.apache.hadoop.hbase.*;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.*;

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

import java.util.List;

import org.apache.hadoop.hbase.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.client.Table;


/**
 * @Author 海龟
 * @Date 2020/10/26 11:17
 * @Desc HbaseAPI操作
 */
public class Hbase_test {
    static Configuration configuration = new CompoundConfiguration();

    static {
        configuration = HBaseConfiguration.create(); //创建HBase配置对象
        configuration.set("hbase.rootdir", "hdfs://master:9000/hbase"); //hbase 根目录
        configuration.set("hbase.master", "hdfs://master:60000");          //hbase 主节点端口
        configuration.set("hbase.zookeeper.property.clientPort", "2181");      //zookeeper端口
        configuration.set("hbase.zookeeper.quorum", "master,slave1,slave2");    //zookeeper服务
    }

    /*
     * 创建表
     * create 'tablename','cf1','cf2'
     */
    public static int creatTable(String tableName, String[] family) throws Exception {

        //1.初始化连接对象 Admin
        //2.初始化表信息对象 HTableDescripto
        //3.循环创建列 设置最大版本数 表添加列addFamily
        //4.判断表是否存在 tableExists
        //5.创建表对象并把表信息对象添加到表对象里 createTable
        //6.关闭连接

        //Admin admin = new HbaseAdmin(configuration);
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        HTableDescriptor table = new HTableDescriptor(TableName.valueOf(tableName));

        for (String str : family) {
            HColumnDescriptor column = new HColumnDescriptor(str);
            column.setMaxVersions(3);   //设置最大版本数
            column.setTimeToLive(1000); //设置存活时间
            table.addFamily(column);  //添加列族
        }

        //判断表是否存在，存在返回-1
        if (admin.tableExists(TableName.valueOf(tableName))) {
            System.out.println(tableName + "已存在");
            return -1;
        }

        admin.createTable(table);
        admin.close();
        System.out.println("create success 成功");
        return 1;
    }

    /*
     * 查询所有表(list)
     */
    public static void catTable() throws Exception {
        //1.初始化连接对象 Admin
        //2.初始化表对象列表 listTables
        //3.循环输出下标值
        //4.关闭连接
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        HTableDescriptor[] hTableDescriptors = admin.listTables();
        for (int i = 0; i <= hTableDescriptors.length; i++) {
            System.out.println(hTableDescriptors[i].toString());
        }
        admin.close();

    }

    /*
    增加一个列族
    */
    public static void addColumnOne(String tableName, String ColumnFamily) throws Exception {
        //1.创建连接对象
        //2.创建列信息对象
        //3.启用表
        //4.添加列族
        //5.关闭连接
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        HColumnDescriptor column = new HColumnDescriptor(Bytes.toBytes(ColumnFamily));

        if (admin.isTableEnabled(TableName.valueOf(tableName)) == false) {
            admin.enableTable(TableName.valueOf(tableName));
        }
        admin.addColumn(TableName.valueOf(tableName), column);
        column.setTimeToLive(3);
        column.setMaxVersions(2);
        System.out.println("创建列族成功！！");
        admin.close();
    }


    /*
     * 删除表
     */
    public static int deleteTable(String tableName) throws Exception {

        //1.初始化连接对象 Admin
        //2.禁用表 disableTable
        //3.删除表 deleteTable
        //4.判断是否删除
        //5.关闭连接
        //HBaseAdmin admin = new HBaseAdmin(configuration);
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        if (admin.isTableEnabled(TableName.valueOf(tableName)) == true) {
            admin.disableTable(TableName.valueOf(tableName));
        }
        admin.deleteTable(TableName.valueOf(tableName));
        if (admin.tableExists(TableName.valueOf(tableName)) == false) {
            System.out.println(tableName + "已删除");
            return 1;
        }
        admin.close();
        return -1;
    }

    /*
    删除一个列族,列值(第一种方法）
     */
    public static void deleteOreations1(String tableName,
                                       String ColumnFamily) throws Exception {
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        if (admin.isTableEnabled(TableName.valueOf(tableName)) == true) {
            admin.disableTable(TableName.valueOf(tableName));
        }
        admin.deleteColumn(TableName.valueOf(tableName), Bytes.toBytes(ColumnFamily));
        admin.close();
        System.out.println("删除成功！！");

    }

     /*
    删除一个列族,列值(第二种方法）
     */

    public static void deleteOreations2(String tableName,String rowKey,
                                       String ColumnFamily,String ColumnName,String value) throws Exception {
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        if(admin.isTableEnabled(TableName.valueOf(tableName))==false){
            admin.enableTable(TableName.valueOf(tableName));
        }
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        delete.addColumn(Bytes.toBytes(ColumnFamily),Bytes.toBytes(ColumnName)); //无版本数（时间戳）
//
//        // delete.addColumn(Bytes.toBytes(ColumnFamily),Bytes.toBytes(ColumnName),);//有版本数（时间戳）
        boolean b = table.checkAndDelete(Bytes.toBytes(rowKey),Bytes.toBytes(ColumnFamily)
                ,Bytes.toBytes(ColumnName),Bytes.toBytes(value),delete);

        table.delete(delete);
                System.out.println("Delete STATUS:" + b);

    }

    /*
      插入数据(put 'tablename','rowkey','familyname:key','value')
     */
    public static void putTable_Data(String tableName, String rowKey, String ColumnsFamily,
                                     String ColumnName, String value) throws Exception {

        //1.初始化连接对象 Admin
        //2.初始化表对象指定表 Table
        //3.初始化put操作指定行键 Put
        //4.put方法添加数据 addColumn
        //5.table对象提交Put对象
        //6.关闭连接
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        if(admin.isTableDisabled(TableName.valueOf(tableName)) == true){
            admin.enableTable(TableName.valueOf(tableName));
        }
        Put put = new Put(Bytes.toBytes(rowKey));
        put.addColumn(Bytes.toBytes(ColumnsFamily), Bytes.toBytes(ColumnName), Bytes.toBytes(value));

        table.put(put);
        table.close();
        admin.close();
    }


    /*
     * 追加某列的值
     */
    public static void append(String tableName, String rowkey
            , String ColumnFamily, String ColumnName, String value) throws Exception {
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        if (admin.isTableEnabled(TableName.valueOf(tableName)) == false) {
            admin.enableTable(TableName.valueOf(tableName));
        }
        Append append = new Append(Bytes.toBytes(rowkey));
        append.add(Bytes.toBytes(ColumnFamily), Bytes.toBytes(ColumnName), Bytes.toBytes(value));
        table.append(append);
        admin.close();
        table.close();
    }


    /*
     * 插入批量插入 Put<list>
     * */
    public static void putTables_Date(String tableName, String rowKey, String ColumnFamile) throws Exception {
        //1.初始化连接对象 Admin
        //2.通过Arraylist构造List<Put>容器
        //3.调用tableExists 判断表是否存在，存在就循环插入数据
        //4.put方法添加数据
        //5.关闭连接

        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        List<Put> putList = new ArrayList<Put>();
        if (admin.tableExists(TableName.valueOf(tableName)) == true) {
            for (int i = 0; i <= 10; i++) {
                Put put = new Put(Bytes.toBytes(rowKey));
                put.addColumn(Bytes.toBytes(ColumnFamile), Bytes.toBytes("ColumnName" + i), Bytes.toBytes("haigui" + i));
                putList.add(put);
            }
        } else {
            System.out.println("该表不存在");
        }
        table.put(putList);
        table.close();
        admin.close();
    }


    /*
     检查和插入数据
     */
    public static void checkAndPut(String tableName,
                                   String rowKey, String ColumnFamile,
                                   String ColumnName, String value) throws Exception {

        //1.初始化连接对象 Admin
        //2.判断表是否存在，存在就创建表对象，初始化表对象和Put对象，put添加数据
        //3.调用checkAndPut方法，check一下，如果改列有没有值，则执行put操作

        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        if (admin.tableExists(TableName.valueOf(tableName)) == true) {
            Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
            Put put = new Put(Bytes.toBytes(rowKey));
            put.addColumn(Bytes.toBytes(ColumnFamile),
                    Bytes.toBytes(ColumnName), Bytes.toBytes(value));

            //put
            boolean test1 = table.checkAndPut(Bytes.toBytes(rowKey), Bytes.toBytes(ColumnFamile)
                    , Bytes.toBytes(ColumnName), Bytes.toBytes(value), put);


            System.out.println("Put STATUS:" + test1);


        }
    }

    /*
     根据rowkey查询 get 'tablename','rowkey'
     */

    public static void RowskeysCat(String tableName, String rowsKey) throws Exception {


        //1.初始化表对象指定表 Table
        //2.初始化Get对象 Get
        //3.调用get方法 get
        //4.输出返回值

        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        Get get = new Get(Bytes.toBytes(rowsKey));
        System.out.println("---------------旧方法（已弃用）---------------");
        Result result1 = table.get(get);
        List<KeyValue> values = result1.list();
        for (KeyValue value : values
        ) {
            //列族
            byte[] columsFamily = value.getFamily();
            String familyStr = Bytes.toString(columsFamily);
            //列限定符
            byte[] colums = value.getQualifier();
            String columsStr = Bytes.toString(colums);
            //值
            byte[] valueValue = value.getFamily();
            String valueStr = Bytes.toString(valueValue);
            //时间戳
            Long TimeStampValue = value.getTimestamp();
            String ts = String.valueOf(TimeStampValue);

            System.out.print(familyStr + ":");
            System.out.print(columsStr + "\t\t");
            System.out.print("value= " + valueStr + " ,");
            System.out.println("TimeStamp = " + ts);
        }

        System.out.println("---------------新方法-------------------");
        Result result2 = table.get(get);
        Cell[] cells = result2.rawCells();
        for (Cell cell : cells
        ) {
            //列族
            byte[] columsFamily = CellUtil.cloneFamily(cell);
            String familyStr = Bytes.toString(columsFamily);
            //列限定符
            byte[] colums = CellUtil.cloneQualifier(cell);
            String columsStr = Bytes.toString(colums);
            //值
            byte[] valueValue = CellUtil.cloneValue(cell);
            String valueStr = Bytes.toString(valueValue);
            //时间戳
            Long TimeStampValue = cell.getTimestamp();
            String ts = String.valueOf(TimeStampValue);

            System.out.print(familyStr + ":");
            System.out.print(columsStr + "\t\t");
            System.out.print("value= " + valueStr + " ,");
            System.out.println("TimeStamp = " + ts);
        }
        table.close();
    }


    /*
     * 查询指定的列 get 'person','tableName','cf1:name'
     */
    public static void getResule_Column(String tableName, String rowKey, String ColumsFamily,
                                        String ColumnName) throws Exception {


        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        Get get = new Get(Bytes.toBytes(rowKey));
        get.addColumn(Bytes.toBytes(ColumsFamily), Bytes.toBytes(ColumnName));
        Result result = table.get(get);
//        byte[] columnsfamily = result.getFamilyMap(Bytes.toBytes(rowKey));
        byte[] data1 = result.getValue(Bytes.toBytes(ColumsFamily), Bytes.toBytes(ColumnName));

        //        List<KeyValue> column = result.getColumn(Bytes.toBytes(ColumsFamily), Bytes.toBytes(ColumnName));
        //            System.out.println(Bytes.toString(k.get));

        //System.out.println("" + Bytes.toString(data1));
//        for (KeyValue columns:column
//             ) {
//            System.out.println( Bytes.toString(columns.getValue()));
//        }
        System.out.println("" + Bytes.toString(data1));
    }


    /*
     * 修改列族的属性
     */
    public static void AlterColumnsFamily(String tableName, String ColumnsFamily) throws Exception {
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        if (admin.isTableEnabled(TableName.valueOf(tableName)) == true) {
            admin.disableTable(TableName.valueOf(tableName));
        }
        HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(ColumnsFamily);
        //数据保存的最大版本数
        hColumnDescriptor.setMaxVersions(3);
        //数据保存的最长时间
//        hColumnDescriptor.setTimeToLive(1000);
        //将修改后的描述对象应用到表
        admin.modifyColumn(TableName.valueOf(tableName),hColumnDescriptor);
        admin.close();
    }

    /*
    让某列的数字加1
     */
    public static void IncreamentColumn(String tableName, String rowKey, String ColumsFamily,
                                        String ColumnName, Long value) throws Exception {
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        if (admin.isTableEnabled(TableName.valueOf(tableName)) == false) {
            admin.enableTable(TableName.valueOf(tableName));
        }
        //添加一个列
        Put put = new Put(Bytes.toBytes(rowKey));
        put.addColumn(Bytes.toBytes(ColumsFamily), Bytes.toBytes(ColumnName), Bytes.toBytes(value));
        table.put(put);
        //给列的值值
        Increment increment = new Increment(Bytes.toBytes(rowKey));
        increment.addColumn(Bytes.toBytes(ColumsFamily), Bytes.toBytes(ColumnName), 10L);
        table.increment(increment);
        table.close();
        admin.close();

    }


    /*
    判断数据是否存在
     */
    public static void isValueExist(String tableName, String rowkey,String ColumnsFamily,String ColumnsName
            ) throws Exception {
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));

//        boolean result = table.exists(get);

        if(admin.isTableEnabled(TableName.valueOf(tableName)) == false){
            admin.enableTable(TableName.valueOf(tableName));

        }
        Get get = new Get(Bytes.toBytes(rowkey));
        Result result = table.get(get);
        byte[] value = result.getValue(Bytes.toBytes(ColumnsFamily), Bytes.toBytes(ColumnsName));
//        System.out.println(Bytes.toString(value));
        if( value != null){
            System.out.println("删除成功！！");
        }
        else {
            System.out.println("该表的值不存在");
        }

    }


    /*
    遍历表输出数据
     */
    public static void ScanTable(String tableName,String rowkey,
                                 String ColumnsFamily,String ColumnsName)throws Exception {
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        Scan scan = new Scan(Bytes.toBytes(rowkey));
        //查询指定到列的值
        //scan.addColumn(Bytes.toBytes(ColumnsFamily), Bytes.toBytes(ColumnsName));
        scan.addFamily(Bytes.toBytes(ColumnsFamily));
        ResultScanner scanner = table.getScanner(scan);
        for (Result results : scanner
        ) {
            Cell[] cell = results.rawCells();
            for (Cell cells : cell
            ) {

                //列族
                byte[] columsFamily = CellUtil.cloneFamily(cells);
                String familyStr = Bytes.toString(columsFamily);
                //列限定符
                byte[] colums = CellUtil.cloneQualifier(cells);
                String columsStr = Bytes.toString(colums);
                //值
                byte[] valueValue = CellUtil.cloneValue(cells);
                String valueStr = Bytes.toString(valueValue);
                //时间戳
                Long TimeStampValue = cells.getTimestamp();
                String ts = String.valueOf(TimeStampValue);

                System.out.print(familyStr + ":");
                System.out.print(columsStr + "\t\t");
                System.out.print("value= " + valueStr + " ,");
                System.out.println("TimeStamp = " + ts);
            }
        }
    }

    /*
    遍历操作
     */
    public static void ScanOreations(String tableName,String rowKey,String ColumnsFamily,
                                     String ColumnsName)throws Exception {
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        if(admin.isTableDisabled(TableName.valueOf(tableName))==true){
            admin.enableTable(TableName.valueOf(tableName));
        }
        //扫描整个表
//        Scan scan = new Scan();
//        ResultScanner tableInfo = table.getScanner(scan);
//        for (Result result:tableInfo
//             ) {
//            System.out.println(result.toString());
//        }
//        tableInfo.close();

        //扫描表的某个列族
//        Scan rkscan = new Scan(Bytes.toBytes(rowKey));
//        Scan cfscan = rkscan.addFamily(Bytes.toBytes(ColumnsFamily));
//        ResultScanner colfamilyInfos = table.getScanner(cfscan);
//        for (Result colfamilyInfo:colfamilyInfos
//             ) {
//            System.out.println(colfamilyInfo.toString());
//        }
//        colfamilyInfos.close();

        //扫描某个列
//        Scan scan = new Scan(Bytes.toBytes(rowKey));
//        Scan cnscan = scan.addColumn(Bytes.toBytes(ColumnsFamily), Bytes.toBytes(ColumnsName));
//        ResultScanner cnInfos = table.getScanner(cnscan);
//        for (Result cnInfo:cnInfos
//             ) {
//            System.out.println(cnInfo);
//        }
//    }

        //扫描值
//        Scan scan = new Scan(Bytes.toBytes(rowKey));
//        Scan scan1 = scan.addFamily(Bytes.toBytes(ColumnsFamily));
//        ResultScanner scanner = table.getScanner(scan1);
//        for (Result scand : scanner
//        ) {
//            Cell[] cells = scand.rawCells();
//            for (Cell cell : cells
//            ) {
//                byte[] cf = CellUtil.cloneFamily(cell);
//                byte[] cn = CellUtil.cloneQualifier(cell);
//                byte[] bytes = CellUtil.cloneValue(cell);
//                long timestamp = cell.getTimestamp();
//
//                System.out.print(Bytes.toString(cf) + ":");
//                System.out.print(Bytes.toString(cn) + "\t\t");
//                System.out.print("value= " +  Bytes.toString(bytes) + " ,");
//                System.out.println("TimeStamp = " + timestamp);
//            }
//        }

        /*
        扫描全表历史版本数据
         */
        Scan scan = new Scan();
        Scan scan1 = scan.setMaxVersions();
        ResultScanner scanner = table.getScanner(scan1);
        for (Result data:scanner
             ) {
            String[] line = data.toString().split(",");
            for (String i:line
                 ) {
                System.out.println(i);
            }

        }
    }

    /*
       扫描全表并设置起始结束行键
        */
    public static void scanStart_Stop(String tableName,String start_rowkey,String stop_rowkey)throws Exception{
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        if(admin.isTableDisabled(TableName.valueOf(tableName))==true){
            admin.enableTable(TableName.valueOf(tableName));
        }
        Scan scan = new Scan();
        scan.withStartRow(Bytes.toBytes(start_rowkey),false);
        scan.withStopRow(Bytes.toBytes(stop_rowkey),true);
        ResultScanner scanner = table.getScanner(scan);
        for (Result s:scanner
             ) {
            String[] split = s.toString().split(",");
            for (String line:split
                 ) {
                System.out.println(line);
            }

        }

    }

    /*
    查询多版本数
     */
    public static void getVersions(String tableName,String rowkey)throws Exception{
        Get get = new Get(rowkey.getBytes());
        get.setMaxVersions(3);
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        Result result = table.get(get);
        Cell[] cell = result.rawCells();
        for (Cell cells : cell
            ) {
                //列族
                byte[] columsFamily = CellUtil.cloneFamily(cells);
                String familyStr = Bytes.toString(columsFamily);
                //列限定符
                byte[] colums = CellUtil.cloneQualifier(cells);
                String columsStr = Bytes.toString(colums);
                //值
                byte[] valueValue = CellUtil.cloneValue(cells);
                String valueStr = Bytes.toString(valueValue);
                //时间戳
                Long TimeStampValue = cells.getTimestamp();
                String ts = String.valueOf(TimeStampValue);

                System.out.print(familyStr + ":");
                System.out.print(columsStr + "\t\t");
                System.out.print("value= " + valueStr + " ,");
                System.out.println("TimeStamp = " + ts);
            }
        }

     /*
     指定条件查询
      */
    public static void getWhere(String tableName,String rowKey,String ColumnsFamily,
                                String ColumnsName)throws Exception{
        Admin admin = ConnectionFactory.createConnection(configuration).getAdmin();
        Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
        Scan scan = new Scan();
        RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.GREATER_OR_EQUAL,
                new BinaryComparator(Bytes.toBytes("rw001")));
        scan.setFilter(rowFilter);
        ResultScanner scanner = table.getScanner(scan);
        for (Result result:scanner
             ) {
            for (Cell cells:result.rawCells()
                 ) {
                //列族
                byte[] columsFamily = CellUtil.cloneFamily(cells);
                String familyStr = Bytes.toString(columsFamily);
                //列限定符
                byte[] colums = CellUtil.cloneQualifier(cells);
                String columsStr = Bytes.toString(colums);
                //值
                byte[] valueValue = CellUtil.cloneValue(cells);
                String valueStr = Bytes.toString(valueValue);
                //时间戳
                Long TimeStampValue = cells.getTimestamp();
                String ts = String.valueOf(TimeStampValue);

                System.out.print(familyStr + ":");
                System.out.print(columsStr + "\t\t");
                System.out.print("value= " + valueStr + " ,");
                System.out.println("TimeStamp = " + ts);
            }

        }

    }

    /*
统计行
     */
public static void rowCount(String tableName)throws IOException{
    int rowCount = 0;
    Table table = ConnectionFactory.createConnection(configuration).getTable(TableName.valueOf(tableName));
    Scan scan = new Scan();
    scan.setFilter(new FirstKeyOnlyFilter());
    ResultScanner scanner = table.getScanner(scan);
    for (Result result:scanner
         ) {
        rowCount += result.size();
    }
    System.out.println(rowCount);
}

    public static void main(String[] args) throws Exception {
        //创建表
        //creatTable("WordCount", new String[]{"cf"});

        //查看所有表
        //catTable();

        //删除表
        //deleteTable("stu2018135204");

        //插入数据
        //putTable_Data("WordCount", "1", "cf","word", "hadoop,storm,spark");





        //插入多行表
        //putTables_Date("haigui","rk001", "cf1");
        //putTables_Date("haigui", "rk001");

        //按行查询表
        //RowskeysCat("haigui", "rk001");

        getResule_Column("score", "Lucy", "score", "English");

        //检查并插入
        //checkAndPut("jjl","rk001","cf", "name","haigui");

        //添加列
        //append("haigui","rk001","cf2","age","1");


        //添加一个列族
        //addColumnOne("haigui","cf2");

        //删除一个列族
        //deleteOreations1("haigui","age");
        //deleteOreations2("score", "Lilly", "score","English", "86");

        //修改列族属性
        //AlterColumnsFamily("score","score");

        //让值加1
        //IncreamentColumn("haigui","rk001","cf3","age",1L);



        //判断数据是否存在
        //isValueExist("haigui","rk001","cf1","name");

        //遍历操作
        //ScanTable("haigui","rk001","cf2","age");
        //ScanOreations("haigui","rk001","cf1","name");
        //scanStart_Stop("student1","1001","1002");

        //getVersions("haigui","cf2");

        //rowCount("score");
    }
}
一条小海龟
关注
专栏目录
java操作HBase增删改查基础
login_sonata的博客
11-28 1393
完整代码在最后部分，有注释，可以直接跳过去看代码。环境是我之前搭的Hadoop和hbase，详见：分布式HBase安装配置和基础学习，但是他们在虚拟机里，eclipse在win10，所以要在win下添加虚拟机的ip映射（这一步或许不需要，看实际情况），修改C:\Windows\System32\drivers\etc\hosts文件，添加： 10.4.20.49 Master 10.4.20.
HBase--JavaAPI的操作，创建表修改表，增删改查数据
SOARING
04-30 4010
DDL： public class HbaseClientDemo { Connection conn = null; @Before public void getConn() throws Exception{ // 构建一个连接对象 Configuration conf = HBaseConfiguration.create(); // 会自动加载hbase-site...
hbase java api 访问 查询、分页
11-24
hbase java api 访问 查询、分页 详情请看：http://blog.csdn.net/wild46cat/article/details/53321409
HBase Java Api
qq_42933029的博客
11-29 924
任务目标 1.了解HBase语言的基本语法 2.了解HBase开发的原理 3.了解HBase Java API的使用 相关知识 HBase与Hadoop一样，都是用Java编写的，所以HBase对Java支持是必须的，HBase Java API核心类介绍如下： 1.HBaseConfiguration类 HBaseConfiguration是每一个HBase Client都会使用到的对象，它代表...
java api操作hbase
成都往右的博客
11-01 963
HBASE是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用HBASE技术可在廉价PC Server上搭建起大规模结构化存储集群。 HBASE的目标是存储并处理大型的数据，更具体来说是仅需使用普通的硬件配置，就能够处理由成千上万的行和列所组成的大型数据。
HBase API 操作
lxpqxl的博客
12-05 1061
环境准备 HBase API 需要依赖的 pom.xml <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-server</artifactId> <version>1.3.1</version> </dependenc...
Hbase Java API
11-20
HBase是Hadoop的数据库，能够对大数据提供随机、实时读写访问。他是开源的，分布式的，多版本的，面向列的，存储模型。
Java操作Hbase进行建表、删表以及对数据进行增删改查
05-14
Java 操作 Hbase 进行建表、删表以及对数据进行增删改查 一、Hbase 简介 Hbase 是一个开源的、分布式的、基于 column-family 的 NoSQL 数据库。它是基于 Hadoop 的，使用 HDFS 作为其存储层。Hbase 提供了高性能、...
利用Hbase相关的API，包括对HBase的增删改查等操作
11-15
在本文中，我们将深入探讨如何使用Java API进行HBase的操作，包括增、删、改、查等基本功能。HBase是一个分布式、版本化的NoSQL数据库，它构建在Hadoop文件系统（HDFS）之上，提供了高可靠性、高性能、可伸缩的数据...
代码中利用Hbase相关的API，包括对HBase的增删改查等操作
最新发布
11-15
HBase提供了一套Java API，使得开发者能够轻松地进行数据的增删改查操作。本教程将深入探讨如何在代码中利用HBase API进行基本的数据操作。 首先，为了使用HBase API，我们需要在项目中引入相应的依赖。由于HBase是...
HBase的API操作---增删改查
TT15751097576的博客
09-21 965
HBase的API操作—增删改查 Java包的版本一定要统一，防止出现版本问题 第一步：创建maven工程 第二部：进入maven官网，输入三个版本jar包 通过类去找包： 问题：我知道一个类名，但是不知道这是那个包的。（通过类去找包的方法） 百度一下：search.maven.org 进入官网 比如：HBase 在输入 Admin //2.连接客户端的类 <!-- https:...
HBase Java API
hujieliang123的博客
02-28 764
文章目录HBase Java API创建HBase模块并导入Maven依赖HBase Java APIHBase Java API 常用操作 HBase Java API 创建HBase模块并导入Maven依赖 <dependencies> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-cl
HBase JAVA API
qq_43533693的博客
10-13 4043
HBase JAVA API 实验目的 1.了解HBase语言的基本语法 2.了解HBase开发的原理 3.了解HBase Java API的使用 实验原理 HBase与Hadoop一样，都是用Java编写的，所以HBase对Java支持是必须的，HBase Java API核心类介绍如下： 1.HBaseConfiguration类 HBaseConfiguration是每一个HBase Client都会使用到的对象，它代表HBase配置信息，有两种构造方式： ①public HBaseConfigura
HBASE-JAVA-API
m0_47310235的博客
05-04 1318
对象中的经度和纬度列中。这段代码是一个 Java 语言的方法，它的作用是从 HBase 数据库中的名为 “stu” 的表中扫描并返回行键在 “1500100888” 和 “1500100900” 之间的前 10 行数据。它的主要作用是根据指定的条件扫描表中的行，并返回符合要求的行数据。这段代码是一个 Java 语言的方法，它的作用是从 HBase 数据库中表名为 “t1” 的表中删除一行，该行的行键为 “rk1”。需要注意的是，如果某一行数据中包含的列的数量不固定，可以使用上述方式获取该行数据中的所有列。
java操作Hbase API
m0_37615458的博客
08-05 164
前提条件，启动hadoop集群，zookeeper集群，Hbase集群，访问hbase的web页面 <!--添加hbase相关依赖--> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId> &lt...
Hbase的JavaAPI
weixin_52189442的博客
10-19 965
Hbase的JavaAPI一、java操作Hbase步骤二、添加依赖三、获取连接四、新增、删除命名空间五、新增表五、修改表六、删除表七、DML操作1、增加一行或多行数据2、删除一行或多行或一个单元格或多个单元格3、获取一行或多行数据或一行的列族或单元格4、获取整张表数据5、利用缓存批量写入6、使用importTsv工具上传数据 一、java操作Hbase步骤 java操作Hbase步骤： 1、添加依赖 2、获取HbaseConfiguration对象 3、设置zookeeper地址 4、获取连接对象 5、
HBase 的 Java Api
菜鸡也有大佬梦
04-11 132
整合 依赖 <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId> <version>2.2.5</version> </dependency> <dependency>
Hbase之JAVA API增删查改
小方块的博客
07-07 593
Hbase增删改查
java调用hbase进行数据增删改查
06-06
Java可以通过HBase的Java API来实现对HBase数据的增删改查操作。以下是示例代码： 1. 首先需要创建一个HBase配置对象`Configuration`并设置相关参数： ```java Configuration conf = HBaseConfiguration.create();...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一条小海龟

谢谢你的打赏，微臣会好好努力达

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

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

打赏作者

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

抵扣说明：

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

余额充值