Hbase的Java客户端续

Java客户端—插入更新数据 put

1. put(Put) 插入一行数据
2. put(List) 插入多行数据
3. 数据的插入必要的内容 表名 行建 列族:属性 值 （ Put 方式不好 一行插入一次 进行一次RPC请求）

//获取操作数据的表对象
        Table table = Hbase_Utils.getTable("tb_test01");
        //设定行键 rk1000,rk2000
        Put put = new Put(Bytes.toBytes("rk1000"));
        Put put2 = new Put(Bytes.toBytes("rk2000"));
        //向行键rk1000添加数据   列族  属性  值
        put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("name"), Bytes.toBytes("yangmi"));
        put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("name"), Bytes.toBytes("wangyijin"));//自动刷新数据
        put.addColumn(Bytes.toBytes("cf2"), Bytes.toBytes("age"), Bytes.toBytes(19));
        //向行键rk2000添加数据   列族  属性  值
        put2.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("name"), Bytes.toBytes("jujingyi"));
        put2.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("age"), Bytes.toBytes(17));
        put2.addColumn(Bytes.toBytes("cf2"), Bytes.toBytes("hobby"), Bytes.toBytes("eat"));
        //放到list 集合中
        List<Put> ls=new ArrayList<>();
        ls.add(put);
        ls.add(put2);
        table.put(ls);
        table.close();

Java客户端批次插入数据( BufferedMutator)

使用缓存批次的形式发送RPC请求 , 减少RPC的请求次数 , 插入数据的效率会比put方式效率高, 但是对于大量的静态数据也并不适合!

 /**
         * 批次插入数据
         */
        //获取连接对象
        Connection conn = Hbase_Utils.getHbaseConnection();
        //
        BufferedMutator bufferedMutator = conn.getBufferedMutator(TableName.valueOf("tb_test01"));
        Put put = new Put("rk3000".getBytes());
        put.addColumn("cf1".getBytes(),"name".getBytes(),"fengwu".getBytes());
        bufferedMutator.mutate(put);//put 继承BufferedMutator 插入数据
         将缓存在本地的数据   请求Hbase插入
        bufferedMutator.flush();
        bufferedMutator.close();

Java客户端获取数据-scan()

1. 全表扫描数据
2. 可以指定扫描范围 scan.withStartRow(“rk002”.getBytes()) ;// 起始行 包括 scan.withStopRow(“rk004”.getBytes()); // 结束行不包含
3. 可以指定扫面某个列族
4. 可以指定扫描某个列族的属性

工具类utils扫描数据

 /**
         * 扫描表的数据信息
         */
        //只要有下一个单元格进入循环
        while (result.advance()){
            //获取当前的单元格对象
            Cell cell = result.current();
            //拿到单元格中的 行键  列族  属性   值
            byte[] cloneRow = CellUtil.cloneRow(cell);
            byte[] cloneFamily = CellUtil.cloneFamily(cell);
            byte[] cloneQualifier = CellUtil.cloneQualifier(cell);
            byte[] cloneValue = CellUtil.cloneValue(cell);
            String row = new String(cloneRow);
            String cf = new String(cloneFamily);
            String qualifier = new String(cloneQualifier);
            String value = new String(cloneValue);
            System.out.println(row+"-->"+cf+":"+qualifier+":"+value);

  /**
         * 扫描一个表中的所有数据
         */
        Table tb_imp = Hbase_Utils.getTable("tb_imp");
        // 多行  多列族 多属性
        Scan scan = new Scan();
        //扫描全表数据
        ResultScanner results = tb_imp.getScanner(scan);
         思路  一行     Result  行
        Iterator<Result> iterator = results.iterator();
        while (iterator.hasNext()){
            //拿到每一个行键
            Result result = iterator.next();
            //调用方法展示数据  遍历多个单元格
            Hbase_Utils.showData(result);
        }
        tb_imp.close();

获取一个列族的数据

Table tb_test01 = Hbase_Utils.getTable("tb_test01");
        //限制输出前几条行键   从指定行键到终止行键
        /*Scan scan = new Scan();
        //输出前三个行键
        scan.setLimit(3);
        //起始行键
        scan.withStartRow("rk1000".getBytes());
        //终止行键
        scan.withStopRow("rk2000".getBytes());
        ResultScanner results = tb_test01.getScanner(scan);*/
        // 查询指定列族的所有数据
        ResultScanner resultScanner = tb_test01.getScanner(Bytes.toBytes("cf1"));
        Iterator<Result> iterator = resultScanner.iterator();
        while (iterator.hasNext()){
            Result result = iterator.next();
            Hbase_Utils.showData(result);
        }
        tb_test01.close();

Shell客户端插入数据

1. 在linux中建立文件插入静态数据并上传到hdfs上的指定输入目录下
2. 在hbase中建立一张表 ‘tb_imp’
3. 根据数据 生成hbase文件 hbase 类全路径 分隔符 行键属性 输出目录 要操作数据的表 输入目录 hbase org.apache.hadoop.hbase.mapreduce.ImportTsv -Dimporttsv.separator=,
   -Dimporttsv.columns=‘HBASE_ROW_KEY,info:name,info:age,info:gender’ -Dimporttsv.bulk.output=/tsv/output tb_imp /tsv/input
4. 将生成的hfile文件导入到hbase表中 hbase 类全路径 输出目录 要操作的表 hbase org.apache.hadoop.hbase.mapreduce.LoadIncrementalHFiles /tsv/output
   tb_imp

Java客户端获取数据-get()

1. get数据
2. 可以获取一行
3. 可以获取多行List
4. 可以获取列族
5. 可以获取列族中的属性

        /**
         * 获取一行数据
         * 获取一行一个列族的数据
         * 获取一行的一个列族的一个属性的数据
         */
        Table tb_test01 = Hbase_Utils.getTable("tb_test01");
        //设置行键
        Get get = new Get("rk2000".getBytes());
        //设置列族属性
        Get get1 = get.addColumn("cf2".getBytes(), "hobby".getBytes());
        Result result = tb_test01.get(get1);
        Hbase_Utils.showData(result);
        tb_test01.close();

Java客户端删除数据-delete()

1. 可以删除一行
2. 删除一行的列族
3. 删除某一行的列族的属性
4. 可以删除多行数据 List

  /**
         * 删除一行数据
         * 删除一行的一个列族数据集
         * 删除一行的一个列族的一个属性数据
         */
        Table tb_test01 = Hbase_Utils.getTable("tb_test01");
        Delete delete = new Delete("rk3000".getBytes());
        Delete delete1 = delete.addColumn("cf1".getBytes(), "name".getBytes());
        tb_test01.delete(delete1);
        tb_test01.close();

Java客户端计数器和获取计数器的值

 /**
         * 自增和取值
         */
        Table tb_test01 = Hbase_Utils.getTable("tb_test01");
        Increment increment = new Increment("rk3000".getBytes());
        //第四个参数  自增属性的自增值
        Increment increment1 = increment.addColumn("cf1".getBytes(), "count".getBytes(), 1);
        tb_test01.increment(increment1);
        //获得自增值  getCounter   第四个参数  是否对已经取到的数据再做自增数据
        long l = tb_test01.incrementColumnValue("rk3000".getBytes(), "cf1".getBytes(), "count".getBytes(), 0);
        System.out.println(l);
        tb_test01.close();

Java客户端创建修改命名空间-namespace

package hbase.client;

import hbase.util.Hbase_Utils;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.client.Admin;

public class NameSpace {
    public static void main(String[] args) throws Exception{
        Admin admin = Hbase_Utils.getAdmin();
        //命名空间的构建器
        NamespaceDescriptor.Builder ns1 = NamespaceDescriptor.create("ns1");
        //命名空间的描述器
        NamespaceDescriptor build = ns1.build();
       //设置一些值
        build.setConfiguration("name","wangggang");
        build.setConfiguration("age","35");
        //修改命名空间
//        admin.modifyNamespace(build);   
        //创建命名空间
        admin.createNamespace(build);
        admin.close();
    }
}

如果要在命名空间下建表 namespace:tablename

 TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf("ns1:tb_test02"));

Java客户端获取表的分区信息-list_regions

  //管理对象
        Admin admin = Hbase_Utils.getAdmin();
        //表的分区集合
        List<RegionInfo> tb_test01 = admin.getRegions(TableName.valueOf("tb_region"));
        //循环遍历
        for (RegionInfo regionInfo : tb_test01) {
            //拿取分区属性
            byte[] regionName = regionInfo.getRegionName();
            byte[] startKey = regionInfo.getStartKey();
            byte[] endKey = regionInfo.getEndKey();
            String name = Bytes.toString(regionName);
            String start = Bytes.toString(startKey);
            String end = Bytes.toString(endKey);
            System.out.println(name+"---->"+start+"--->"+end);
        }

PutDetails

package hbase.client;

import com.sun.org.apache.xpath.internal.operations.String;
import hbase.util.Hbase_Utils;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

import java.util.*;

/**
 * putDetail
 */
public class PutDetail {
    public static void main(String[] args) throws  Exception{
        Table tb_test01 = Hbase_Utils.getTable("tb_test01");
        // Put  行 列族 属性  值    (列族 属性  值)单元格
        Put put = new Put("rk1000".getBytes());
        // 一行中的多个列族
        List<java.lang.String> cfs=new ArrayList<>();

        NavigableMap<byte[], List<Cell>> familyCellMap = put.getFamilyCellMap();
        Set<Map.Entry<byte[], List<Cell>>> entries = familyCellMap.entrySet();
        // 遍历每个列族
        for (Map.Entry<byte[], List<Cell>> entry : entries) {
            byte[] key = entry.getKey();
            java.lang.String cf = Bytes.toString(key);
            //将所有的列族存储在list集合中
            cfs.add(cf);
            // 每个列族中所有的单元格
            List<Cell> cells = entry.getValue();
            for (Cell cell : cells) {
                // 获取单元格的属性
                byte[] cloneQualifier = CellUtil.cloneQualifier(cell);
                byte[] cloneValue = CellUtil.cloneValue(cell);
                System.out.println(new java.lang.String(cloneQualifier)+":"+new java.lang.String(cloneValue));
            }
        }
    }
}