4.hbaseApi

1 搭建hbase开发环境

1.1 用idea正常创建maven工程

1.1.1 安装和配置idea

官方下载地址: https://www.jetbrains.com/zh-cn/idea/download/#section=windows

双击 “idea快捷方式”图标

进入主页面

破解idea参考 《idea破解教程.mht》，破解步骤笔记不体现，破解后可无限30重试使用。

1.1.2 安装 maven插件

idea 2021版本，自带 maven 插件，无需安装。

1.1.3 创建maven工程

选择maven工程，配置jdk，点next

点击 finish 完成工程创建。

1.1.4 修改idea 主题样式和字体样式

修改idea 主题样式

修改字体样式

1.1.5 配置maven

1.1.6 修改快捷键

可根据自己喜好更改。

1.1.7 创建代码目录

新建的目录，只是一个纯粹的目录，还需要修改成代码目录，修改方式如下

1）右键要修改的目录 → Mark directory as → Sources Root

2）File → Project Structure... → Modules

或 右键工程 → Open Module Settings

1.2 添加pom依赖

由于cdh每个组件有自己的版本，需要先在webui上查看版本，然后添加的对应的version里

查看版本：

集群 → 主机 → 点主机名称 → 组件

将对应组件的版本添加到依赖中， 要把 + 改成 -，比如：3.0.0-cdh6.3.2

    <dependencies>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>3.0.0-cdh6.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.0.0-cdh6.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>2.1.0-cdh6.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>2.1.0-cdh6.3.2</version>
        </dependency>
    </dependencies>

1.3 添加cdh仓库

由于cdh的依赖包只有cdh有，原有maven和阿里云都没有，需要在pom中配置

    <!-- 使用cdh自带的仓库-->
    <repositories>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>

使得阿里云兼容cdh的 cloudera 仓库，需要修改setting.xml

1.4 将cdh的配置放到工程的资源目录下

1） 下载客户端配置

点hbase服务 → 在操作选项卡中选择“下载客户端配置”

2）将下载下来的配置文件放到工程资源目录下

为了ida工具能加载，可以先rebuild

2 kerberos 认证

由于从windows本地连接cdh的hbase，需要通过kerberos 认证。

2.1 准备的配置文件

1）将 hbase.keytab 文件从服务器下载下来

/data/hbase.keytab

2）将 krb5.conf 文件从服务下载下来

/etc/krb5.conf

3）将下载下来的文件上传到 conf 目录里

2.2 代码认证

    public static void main(String[] args) {
        String krb5Path = "src/main/conf/krb5.conf";
        String principal = "hbase@HAINIU.COM";
        String keytabPath = "src/main/conf/hbase.keytab";
        Configuration conf = HBaseConfiguration.create();
        kerberosAuth(conf,krb5Path,principal,keytabPath);

        try {
            UserGroupInformation loginUser = UserGroupInformation.getLoginUser();
            System.out.println("loginUser:" + loginUser);
        } catch (IOException e) {
            e.printStackTrace();
        }

//        createTable(conf);
    }

   /**
     * kerberos认证
     * @param configuration hadoop配置文件
     * @param krb5Path kerberos配置文件(krb5.conf)路径
     * @param principal 认证主体名
     * @param keytabPath keytab文件路径
     */
    public static void kerberosAuth(Configuration configuration,String krb5Path,String principal,String keytabPath){
        // 通过系统设置参数设置krb5.conf
        System.setProperty("java.security.krb5.conf",krb5Path);
        // 指定kerberos 权限认证
        configuration.set("hadoop.security.authentication","Kerberos");

        // 用 UserGroupInformation 类做kerberos认证
        UserGroupInformation.setConfiguration(configuration);
        try {
            // 参数1：认证主体
            // 参数2：认证文件
            // 相当于采用秘钥文件方式认证
            UserGroupInformation.loginUserFromKeytab(principal,keytabPath);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

3 hbase操作

3.1 建表

步骤：

1） 根据hbase的配置参数，创建目标zookeeper hbase连接

2） 根据连接，获取表的管理对象

3） 创建表描述对象

4） 创建表里面的列族

5） 将列族添加到表里

6） 用管理对象根据 表的描述 创建表

// 创建表 xinniu:table123，列族：cf1, cf2

3.1.1 旧api用法

  // 表名
    static TableName tableName = TableName.valueOf("xinniu:table123");
    private static void createTable() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的管理对象(建表、表上下线、删除表)
            final HBaseAdmin admin = (HBaseAdmin) conn.getAdmin();

            if (admin.tableExists(tableName)) {
                return;
            }

            // create 'xinniu:table123','cf1','cf2'
            // 创建表描述对象
            final HTableDescriptor table = new HTableDescriptor(tableName);
            // 创建列族对象cf1
            final HColumnDescriptor cf1 = new HColumnDescriptor(Bytes.toBytes("cf1"));
            final HColumnDescriptor cf2 = new HColumnDescriptor(Bytes.toBytes("cf2"));
            table.addFamily(cf1);
            table.addFamily(cf2);

            // 用管理对象创建hbase表
            admin.createTable(table);

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

3.1.2 新api用法

    /**
     * 创建hbase表(新api)
     */
    private static void createTableNew() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的管理对象(建表、表上下线、删除表)
            final HBaseAdmin admin = (HBaseAdmin)conn.getAdmin();

            if(admin.tableExists(tableName)){
                System.out.println("tablename " + tableName + " exists!");
                return;
            }

            // create 'xinniu:table234','cf1','cf2'

            // 创建表描述对象
            final TableDescriptorBuilder table = TableDescriptorBuilder.newBuilder(tableName);
            // 创建列族对象cf1、cf2
            final ColumnFamilyDescriptor cf1 = ColumnFamilyDescriptorBuilder
                    .newBuilder(Bytes.toBytes("cf1")).build();
            final ColumnFamilyDescriptor cf2 = ColumnFamilyDescriptorBuilder
                    .newBuilder(Bytes.toBytes("cf2")).build();

            table.setColumnFamily(cf1);
            table.setColumnFamily(cf2);

            // 用管理对象创建hbase表
            admin.createTable(table.build());

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

3.2 单行插入

步骤：

1） 根据hbase的配置参数，创建目标zookeeper hbase连接

2） 根据连接，获取表对象

3） new Put 对象，指定rowkey

4） 给Put 对象添加 列族、列、值

5） 用表对象 调用put() ， 将Put对象的数据插入到表中

插入的是id01

//put 'xinniu:table123','id01', 'cf1:name','n1'

//put 'xinniu:table123','id01', 'cf1:age','11'

//put 'xinniu:table123','id01', 'cf1:sex','boy'

    /**
     * put 一行数据
     */
    private static void putRow() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的操作对象（put、get、can）
            final HTable table = (HTable)conn.getTable(tableName);

            // 创建put对象,put代表一行数据
            //put 'xinniu:table123','id01', 'cf1:name','n1'
            //put 'xinniu:table123','id01', 'cf1:age','11'
            //put 'xinniu:table123','id01', 'cf1:sex','boy'
            Put put = new Put(Bytes.toBytes("id01"));
            put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("name"), Bytes.toBytes("n1"));
            put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("age"), Bytes.toBytes("11"));
            put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("sex"), Bytes.toBytes("boy"));
            // 添加一行数据
            table.put(put);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.3 多行插入

步骤：

1） 根据hbase的配置参数，创建目标zookeeper hbase连接

2） 根据连接，获取表对象

3） List puts = new ArrayList();

4） new Put 对象，指定rowkey

5） 给Put 对象添加 列族、列 值

6） 将创建好的Put对象装到 列表里

7） 用表对象 调用put() ， 将Put对象列表的数据插入到表中

插入的是id02 、id03

//put 'xinniu:table123','id02', 'cf1:name','n2'

//put 'xinniu:table123','id02', 'cf1:age','12'

//put 'xinniu:table123','id02', 'cf1:sex','boy'

//put 'xinniu:table123','id03', 'cf1:name','n3'

//put 'xinniu:table123','id03', 'cf1:age','13'

//put 'xinniu:table123','id03', 'cf1:sex','girl'

    /**
     * put多行数据
     */
    private static void putRows() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的操作对象（put、get、can）
            final HTable table = (HTable)conn.getTable(tableName);
            List<Put> puts = new ArrayList<Put>();

            // 创建put对象,put代表一行数据
            //put 'xinniu:table123','id02', 'cf1:name','n2'
            //put 'xinniu:table123','id02', 'cf1:age','12'
            //put 'xinniu:table123','id02', 'cf1:sex','boy'
            Put put2 = new Put(Bytes.toBytes("id02"));
            put2.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("name"), Bytes.toBytes("n2"));
            put2.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("age"), Bytes.toBytes("12"));
            put2.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("sex"), Bytes.toBytes("boy"));

            //put 'xinniu:table123','id03', 'cf1:name','n3'
            //put 'xinniu:table123','id03', 'cf1:age','13'
            //put 'xinniu:table123','id03', 'cf1:sex','girl'
            Put put3 = new Put(Bytes.toBytes("id03"));
            put3.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("name"), Bytes.toBytes("n3"));
            put3.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("age"), Bytes.toBytes("13"));
            put3.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("sex"), Bytes.toBytes("girl"));

            puts.add(put2);
            puts.add(put3);

            // 添加一行数据
            table.put(puts);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.4 单行查询

get一行的步骤：

1） 根据hbase的配置参数，创建目标zookeeper hbase连接

2） 根据连接，获取表对象

3） new Get 对象

4） 调用表对象的get(), 获取数据，并赋给Result对象（一行数据）

5） Result对象转Cell 数组

6） 遍历Cell 数组，获取每个列族对应的列的数据。

用法：

    /**
     * get一行数据
     */
    private static void getRow() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的操作对象（put、get、can）
            final HTable table = (HTable)conn.getTable(tableName);
            // get 'xinniu:table123','id01'
            Get get = new Get(Bytes.toBytes("id01"));
            // get 'xinniu:table123','id01','cf1'
           get.addFamily(Bytes.toBytes("cf1"));
            // get 'xinniu:table123','id01','cf1:name'
           // get.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("name"));
            // 获取多个版本的数据，先要列族支持，然后再设置获取多版本
           //get.setMaxVersions(3);

            // result代表一行数据
            final Result result = table.get(get);

            // 方式1：直接获取对应列族列的数据
            final byte[] nameBytes = result.getValue(Bytes.toBytes("cf1"), Bytes.toBytes("name"));
            final String name = Bytes.toString(nameBytes);
            final String age = Bytes.toString(
                    result.getValue(Bytes.toBytes("cf1"), Bytes.toBytes("age")));
            final String sex = Bytes.toString(
                    result.getValue(Bytes.toBytes("cf1"), Bytes.toBytes("sex")));
            System.out.println(name + "\t" + age + "\t" + sex);

            // 遍历result结果
            printResult(result);

        } catch (IOException e) {  
            e.printStackTrace();
        }
    }
 /**
     * 输出一行数据
     * @param result
     */
    private static void printResult(Result result) {
        // 遍历result结果
        final Cell[] cells = result.rawCells();
        StringBuilder sb = new StringBuilder();
        for (Cell cell : cells) {
            final String rowkey = Bytes.toString(CellUtil.cloneRow(cell));
            final String cfname = Bytes.toString(CellUtil.cloneFamily(cell));
            final String cname = Bytes.toString(CellUtil.cloneQualifier(cell));
            final String value = Bytes.toString(CellUtil.cloneValue(cell));
            final long timestamp = cell.getTimestamp();
            // id01 column=cf1:age, timestamp=1644830525822, value=11
            sb.append(rowkey)
                    .append("\tcolumn=")
                    .append(cfname)
                    .append(":")
                    .append(cname)
                    .append(", timestamp=")
                    .append(timestamp)
                    .append(", value=")
                    .append(value)
                    .append("\n");

        }

        System.out.println(sb.toString());
    }

在上面的基础上，查询rowkey='id01' cf1:age, 最近三个版本的数据

设置列族支持3个版本

alter 'xinniu:table123',{ NAME =>'cf1', VERSIONS => 3 }

在代码里加上：

Get get = new Get(toBytes("id01"));
// get.addFamily("cf1");
get.addColumn(toBytes("cf1"), toBytes("age"));
get.setMaxVersions(3);

put数据：

put 'xinniu:table123','id01', 'cf1:age','12'

put 'xinniu:table123','id01', 'cf1:age','13'

put 'xinniu:table123','id01', 'cf1:age','14'

查询结果：

3.5 批量查询

用scan

步骤：

1） 根据hbase的配置参数，创建目标zookeeper hbase连接

2） 根据连接，获取表对象

3） new Scan对象

4） 调用表对象的getScanner(), 获取数据，并赋给ResultScanner对象（多行数据）

5） 每次遍历一行数据（Result）

6） Result对象转Cell 数组

7） 遍历Cell 数组，获取每个列族对应的列的数据。

scan用法：

 /**
     * scan多行数据
     */
    private static void scanRows() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的操作对象（put、get、can）
            final HTable table = (HTable)conn.getTable(tableName);

            final Scan scan = new Scan();
            // [id02, id05)
         // scan.withStartRow(Bytes.toBytes("id02"));
          //  scan.withStopRow(Bytes.toBytes("id05"));

         scan.addFamily(Bytes.toBytes("cf2"));

            // Iterable<Result>
            final ResultScanner results = table.getScanner(scan);
            for(Result result : results){
                printResult(result);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

//添加测试数据

put 'xinniu:table123','id04', 'cf1:name','m4'
put 'xinniu:table123','id04', 'cf1:age','14'
put 'xinniu:table123','id04', 'cf2:cert_no','110425'
put 'xinniu:table123','id04', 'cf2:cert_type','身份证'
put 'xinniu:table123','id05', 'cf1:name','m5'
put 'xinniu:table123','id05', 'cf1:age','15'
put 'xinniu:table123','id05', 'cf2:cert_no','110525'
put 'xinniu:table123','id05', 'cf2:cert_type','身份证'
put 'xinniu:table123','id06', 'cf1:age','16'
put 'xinniu:table123','id06', 'cf2:cert_no','110627'
put 'xinniu:table123','id06', 'cf2:cert_type','身份证'

3.6 删除行

步骤：

1） 根据hbase的配置参数，创建目标zookeeper hbase连接

2） 根据连接，获取表对象

3） newDelete对象

4） 调用表对象的delete() 删除指定行的数据

用法：

    /**
     * 删除一行数据
     */
    private static void deleteRow() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的操作对象（put、get、can、delete）
            final HTable table = (HTable)conn.getTable(tableName);

            // 删除id06的所有版本
            final Delete delete = new Delete(Bytes.toBytes("id06"));

            // 删除id06小于等于该时间戳的所有版本
            //final Delete delete = new Delete(Bytes.toBytes("id06"), 1644833316179L);

            table.delete(delete);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

结果：id06 行的数据被删除

3.7 删除列族（DDL）

步骤：

1 根据hbase的配置参数，创建目标zookeeper hbase连接

2 根据连接，获取表的管理对象（HBaseAdmin）

3 调用管理对象的 deleteColumn()， 删除指定列族数据及表的结构

用法：

 /**
     * 删除列族
     */
    private static void deleteCF() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的管理对象(建表、表上下线、删除表)
            final HBaseAdmin admin = (HBaseAdmin)conn.getAdmin();
            admin.deleteColumnFamily(tableName, Bytes.toBytes("cf2"));

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

删除cf2 列族后的结果

3.8 删除表

步骤：

1 根据hbase的配置参数，创建目标zookeeper hbase连接

2 根据连接，获取表的管理对象

3 调用管理对象的 disableTable()，将表下线

4 调用管理对象的 deleteTable()， 删除表。

用法：

    /**
     * 删除表
     */
    private static void deleteTable() {

        // 创建hbase客户端连接
        try {
            final Connection conn = ConnectionFactory.createConnection(conf);
            // 创建hbase表的管理对象(建表、表上下线、删除表)
            final HBaseAdmin admin = (HBaseAdmin)conn.getAdmin();
            // 先下线
            admin.disableTable(tableName);

            // 再删除
            admin.deleteTable(tableName);

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

删除表后，表不存在了。

3.9 完整代码

3.9.1 代码

package com.hainiu;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.security.User;
import static org.apache.hadoop.hbase.util.Bytes.toBytes;

import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.security.UserGroupInformation;

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

public class HbaseOpForJava {

    static TableName tableName = TableName.valueOf("xinniu:table123");
    static Configuration conf = HBaseConfiguration.create();

    public static void main(String[] args) {
        String krb5Path = "src/main/conf/krb5.conf";
        String principal = "hbase@HAINIU.COM";
        String keytabPath = "src/main/conf/hbase.keytab";
        kerberosAuth(conf,krb5Path,principal,keytabPath);

        try {
            UserGroupInformation loginUser = UserGroupInformation.getLoginUser();
            System.out.println("loginUser:" + loginUser);
        } catch (IOException e) {
            e.printStackTrace();
        }

        createTable();
//        createTableNewAPI();
//        putRow();
//        putRows();
//        getRow();
//          scanRows();
//        deleteRow();
//        scanRows();
//        deleteCF();
//        deleteTable();
    }

    /**
     * 删除表操作
     */
    private static void deleteTable() {
        try (
                //获取连接
                Connection conn = ConnectionFactory.createConnection(conf);

                //表管理对象
                HBaseAdmin admin = (HBaseAdmin)conn.getAdmin();
        )
        {
            //下线表
            admin.disableTable(tableName);
            admin.deleteTable(tableName);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除列族
     */
    private static void deleteCF() {
        try (
                //获取连接
                Connection conn = ConnectionFactory.createConnection(conf);

                //表管理对象
                HBaseAdmin admin = (HBaseAdmin)conn.getAdmin();
        )
        {
            admin.deleteColumnFamily(tableName,Bytes.toBytes("cf2"));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除一行
     */
    private static void deleteRow() {
        try (
                // 获取到hbase客户端连接对象
                Connection conn = ConnectionFactory.createConnection(conf);

                // 获取表操作对象
                HTable table = (HTable)conn.getTable(tableName);

        ){

            // 此时会删除掉id06这行所有版本的数据
            Delete delete = new Delete(toBytes("id06"));
            // 此时会删除掉id05这行中时间戳小于等于 1616729733043 的所有版本
//            Delete delete = new Delete(toBytes("id05"), 1616729733043L);

            table.delete(delete);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    /**
     * 查询多行
     */
    private static void scanRows() {
        try (
                // 获取到hbase客户端连接对象
                Connection conn = ConnectionFactory.createConnection(conf);

                // 获取表操作对象
                HTable table = (HTable)conn.getTable(tableName);

        ){
            // 创建scan对象
            Scan scan = new Scan();
            // [id04, id07)
            scan.withStartRow(toBytes("id04"));
            scan.withStopRow(toBytes("id07"));
//          scan.addColumn(toBytes("cf1"), toBytes("age"));
//            scan.setMaxVersions();

            // 返回多行数据，ResultScanner 内部是Iterable<Result>
            ResultScanner results = table.getScanner(scan);
            System.out.println("查询结果：");
            for(Result result : results){
                printResult(result);
            }

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    /**
     * get 一行
     */
    private static void getRow() {
        try (
                // 获取到hbase客户端连接对象
                Connection conn = ConnectionFactory.createConnection(conf);

                // 获取表操作对象
                HTable table = (HTable)conn.getTable(tableName);

        ){
            // 创建get对象
            Get get = new Get(toBytes("id01"));
//          get.addFamily(toBytes("cf1"));
//          get.addColumn(toBytes("cf1"), toBytes("name"));
//          get.setMaxVersions();
//            get.setMaxVersions(3);

            // result代表一行的数据
            Result result = table.get(get);
            // 直接获取指定的数据
            String name = Bytes.toString(result.getValue(toBytes("cf1"), toBytes("name")));
            String age = Bytes.toString(result.getValue(toBytes("cf1"), toBytes("age")));
            String sex = Bytes.toString(result.getValue(toBytes("cf1"), toBytes("sex")));
            System.out.println("name:" + name + ", age:" + age + ", sex:" + sex);

            // 遍历result输出
            //id01  column=cf1:age, timestamp=1616727722872, value=11
            System.out.println("查询结果：");
            printResult(result);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    /**
     * 打印一行数据
     */
    private static void printResult(Result result) {
        StringBuilder sb = new StringBuilder();
        Cell[] cells = result.rawCells();
        for(Cell cell : cells){
            sb.append(Bytes.toString(CellUtil.cloneRow(cell)))
                    .append("\tcolumn=")
                    .append(Bytes.toString(CellUtil.cloneFamily(cell)))
                    .append(":")
                    .append(Bytes.toString(CellUtil.cloneQualifier(cell)))
                    .append(", timestamp=")
                    .append(cell.getTimestamp())
                    .append(", value=")
                    .append(Bytes.toString(CellUtil.cloneValue(cell)))
                    .append("\n");
        }

        System.out.println(sb.toString());
    }

    /**
     * 添加多行
     */
    private static void putRows() {
        try (
                // 获取到hbase客户端连接对象
                Connection conn = ConnectionFactory.createConnection(conf);
                // 获取表操作对象
                HTable table = (HTable)conn.getTable(tableName);
        ){

            // 创建put对象
            //put 'xinniu:table123','id02', 'cf1:name','n2'
            //put 'xinniu:table123','id02', 'cf1:age','12'
            //put 'xinniu:table123','id02', 'cf1:sex','boy'
            //put 'xinniu:table123','id03', 'cf1:name','n3'
            //put 'xinniu:table123','id03', 'cf1:age','13'
            //put 'xinniu:table123','id03', 'cf1:sex','girl'

            List<Put> puts = new ArrayList<Put>();

            Put put1 = new Put(toBytes("id02"));
            put1.addColumn(toBytes("cf1"), toBytes("name"), toBytes("n2"));
            put1.addColumn(toBytes("cf1"), toBytes("age"), toBytes("12"));
            put1.addColumn(toBytes("cf1"), toBytes("sex"), toBytes("boy"));

            Put put2 = new Put(toBytes("id03"));
            put2.addColumn(toBytes("cf1"), toBytes("name"), toBytes("n3"));
            put2.addColumn(toBytes("cf1"), toBytes("age"), toBytes("13"));
            put2.addColumn(toBytes("cf1"), toBytes("sex"), toBytes("girl"));

            puts.add(put1);
            puts.add(put2);

            // 添加多行数据
            table.put(puts);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    /**
     * put 一行数据
     */
    private static void putRow() {
        try (
                // 获取到hbase客户端连接对象
                Connection conn = ConnectionFactory.createConnection(conf);

                // 获取表操作对象
                HTable table = (HTable)conn.getTable(tableName);

        ){

            // 创建put对象
            //put 'xinniu:table123','id01', 'cf1:name','n1'
            //put 'xinniu:table123','id01', 'cf1:age','11'
            //put 'xinniu:table123','id01', 'cf1:sex','boy'
            Put put = new Put(toBytes("id01"));
            put.addColumn(toBytes("cf1"), toBytes("name"), toBytes("n1"));
            put.addColumn(toBytes("cf1"), toBytes("age"), toBytes("11"));
            put.addColumn(toBytes("cf1"), toBytes("sex"), toBytes("boy"));
            // 添加一行数据
            table.put(put);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    /**
     * 用新api创建表
     * @throws IOException
     */
    private static void createTableNewAPI()  {
        try (
                // 获取到hbase客户端连接对象
                Connection conn = ConnectionFactory.createConnection(conf);
                // 获取表管理对象
                HBaseAdmin admin = (HBaseAdmin)conn.getAdmin();
        ){
            // 判断表是否存在
            if(admin.tableExists(tableName)){
                System.out.println(tableName.toString() + " is exists!");
                return;
            }

            // 创建表的描述对象
            TableDescriptorBuilder table = TableDescriptorBuilder.newBuilder(tableName);
            // 创建列族描述对象
            ColumnFamilyDescriptorBuilder cf1 = ColumnFamilyDescriptorBuilder.newBuilder(toBytes("cf1"));
            ColumnFamilyDescriptorBuilder cf2 = ColumnFamilyDescriptorBuilder.newBuilder(toBytes("cf2"));

            table.setColumnFamily(cf1.build());
            table.setColumnFamily(cf2.build());

            // create 'xinniu:table123','cf1','cf2'
            // 用表管理对象建表
            admin.createTable(table.build());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 用旧api创建表
     * @throws IOException
     */
    private static void createTable()  {
        try (
                // 获取到hbase客户端连接对象
                Connection conn = ConnectionFactory.createConnection(conf);
                // 获取表管理对象
                HBaseAdmin admin = (HBaseAdmin)conn.getAdmin();
        ){
            // 判断表是否存在
            if(admin.tableExists(tableName)){
                System.out.println(tableName.toString() + " is exists!");
                return;
            }

            // 创建表的描述对象
            HTableDescriptor table = new HTableDescriptor(tableName);
            // 创建列族描述对象
            HColumnDescriptor cf1 = new HColumnDescriptor(toBytes("cf1"));
            HColumnDescriptor cf2 = new HColumnDescriptor(toBytes("cf2"));

            table.addFamily(cf1);
            table.addFamily(cf2);

            // create 'xinniu:table123','cf1','cf2'
            // 用表管理对象建表
            admin.createTable(table);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * kerberos认证
     * @param configuration hadoop配置文件
     * @param krb5Path kerberos配置文件(krb5.conf)路径
     * @param principal 认证主体名
     * @param keytabPath keytab文件路径
     */
    public static void kerberosAuth(Configuration configuration,String krb5Path,String principal,String keytabPath){
        // 通过系统设置参数设置krb5.conf
        System.setProperty("java.security.krb5.conf",krb5Path);
        // 指定kerberos 权限认证
        configuration.set("hadoop.security.authentication","Kerberos");

        // 用 UserGroupInformation 类做kerberos认证
        UserGroupInformation.setConfiguration(configuration);
        try {
            // 参数1：认证主体
            // 参数2：认证文件
            UserGroupInformation.loginUserFromKeytab(principal,keytabPath);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

3.9.2 pom文件

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hainiu</groupId>
    <artifactId>hainiuhbase</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <!-- 使用cdh自带的仓库-->
    <repositories>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>

    <dependencies>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>3.0.0-cdh6.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.0.0-cdh6.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>2.1.0-cdh6.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>2.1.0-cdh6.3.2</version>
        </dependency>
    </dependencies>

</project>