• HBase的简单学习二

     一 HBase shell

    1.1 Region信息观察

    1.1.1 创建表加命名空间

    1.语法 create ’命名空间:表名‘,'列簇名'

    2.示例：create 'bigdata29:t1','info'
     

    1.1.2 查看命名空间的表

    1.语法 list_namespace_tables '命名空间'

    2.示例 list_namespace_tables 'bigdata29'

    1.1.3 查看region中的某列簇数据

    1.语法 hbase hfile -p -f  查看列簇在habse上的路径

    2.实例：

    hbase hfile -p -f /hbase/data/default/users/c186f7ae5e27dc820aee1959c269dcc6/detail/693737407e0e476bba4ce8e
    c6b9367c6

     注意 行键的设计在hbase中有三大设计原则：唯一性 长度不宜过长 散列性

    刷新数据：flush 'tb'
    合并数据：major_compact 'tb'

    1.1.4 查看表的所有region list_regions

    1.语法 list_regions '表名'

     1.1.5 强制将表切分出来一个region split

    1.语法 split '表名','行键'

    2.会做负载均衡，如果切分过后在同一个节点上可能不均衡，系统自己会做负载均衡

     1.2  预分region解决热点问题

    1. 设计良好的行键：

      • 盐值（Salting）：通过在行键前添加随机前缀（盐值），可以将数据分散到多个不同的区域。这样，即使原始行键存在热点问题，由于盐值的存在，数据也会被均匀地分散到多个区域中。
      • 反转或哈希行键：对于具有递增或递减趋势的行键，可以考虑反转或哈希行键，以打破这种趋势，使得数据更加均匀地分布在不同的区域中。

    2. 预分区：

      • 在创建表时，可以预先设置更多的初始区域，以便在数据写入时，数据可以更加均匀地分布在这些区域中。这有助于减轻单个区域的负载压力。

    3. 使用负载均衡：

      • HBase提供了负载均衡机制，可以自动地将负载过重的区域迁移到负载较轻的区域。确保启用了HBase的自动负载均衡功能，并根据需要调整相关参数。

    4. 优化扫描操作：

      • 尽量避免全表扫描，因为这会导致大量的数据读取和传输，从而加重HBase的负担。如果需要扫描数据，尽量使用范围扫描或过滤器来减少扫描的数据量。

    5. 增加资源：

      • 如果上述方法仍然无法解决热点问题，可以考虑增加HBase集群的资源，如增加更多的RegionServer节点或增加存储设备的容量和性能。

    6. 监控和诊断：

      • 使用HBase提供的监控工具和日志来分析系统的运行状况，及时发现并定位热点问题。通过监控数据的读写速率、区域负载、资源利用率等指标，可以更好地了解系统的运行状况，并采取相应的措施来解决热点问题。

    7. 考虑其他存储方案：

      • 如果HBase的热点问题无法解决或成本过高，可以考虑使用其他存储方案，如分布式文件系统（如HDFS）、NoSQL数据库或其他大数据存储解决方案，根据具体的应用场景和需求选择合适的存储方案。

    1.3 split 建表使用

    1.create 'tb_split','cf',SPLITS => ['e','h','l','r'] 这个建表语句是将表根据行名 划分为5个区域

    2.添加数据

    put 'tb_split','c001','cf:name','first'
    put 'tb_split','f001','cf:name','second'
    put 'tb_split','z001','cf:name','last'

    3.然后去相对的hbase路径寻找

    1.4 scan的进阶使用

     1.5 查看几条数据

    1.5.1 前几条

    1.语法

    scan '表名',{LIMIT=>数字}

     1.5.2 后几条

    1.语法

    scan '表名',{LIMIT=>数字,REVERSED=>true}

     1.5.3 查看指定列的行的几条数据

    1.语法 scan '表名',LIMIT=>数字,COLUMNS=>['列簇信息']

    scan 'teacher',LIMIT=>3,COLUMNS=>['cf:tid']

    1.6 追加

    1.语法 append 'teacher','tid00001','cf:name','123'

    2.追加到之前的内容上

    1.7 get进阶

     

    1.8 incr和counter

     

     1.9  获取region的分割点，清除数据，快照

     二 JAVA API

    2.1  链接数据库

    1.获取hbase集群设置

    Configuration conf = HBaseConfiguration.create();

    2.设置zookeeper集群

    conf.set("hbase.zookeeper.quorum", "master:2181,node1:2181,node2:2181");

    3.获取数据库链接对象

    conn = ConnectionFactory.createConnection(conf);

    这里的参数是hbase集群设置的类

    4.获取数据库操作对象

    admin = conn.getAdmin(); //使用连接对象获取数据库操作对象

    1.     //数据库连接对象
    2.     private Connection conn;
    3.     //数据库操作对象
    4.     private Admin admin;
    5.     @Before
    6.     public void getConnection(){
    7.        try {
    8.            //获取hbase集群的配置文件对象
    9.            //旧方法
    10. //        HBaseConfiguration conn = new HBaseConfiguration();
    11.            Configuration conf = HBaseConfiguration.create();
    12.  
    13.            //配置文件要设置你自己的zookeeper集群
    14.            conf.set("hbase.zookeeper.quorum","master:2181,node1:2181,node2:2181");
    15.  
    16.            //3、获取数据库的连接对象
    17.            Connection conn = ConnectionFactory.createConnection(conf);
    18.  
    19.            //4、获取数据库操作对象
    20.            admin = conn.getAdmin(); //使用连接对象获取数据库操作对象
    21.            System.out.println("数据库连接对象获取成功！！"+conn);
    22.            System.out.println("数据库操作对象获取成功！！"+admin);
    23.            System.out.println("==========================================");
    24.        }catch (Exception e){
    25.            e.printStackTrace();
    26.        }
    27.     }

    2.2 在hbase中创建一张表

    1.先将表名封装成一个TableName的对象，使用ableName中的valueOf

    TableName tn = TableName.valueOf("表名");

    2.使用 TableDescriptorBuilder 类来创建并获取表描述器对象

    TableDescriptorBuilder table = TableDescriptorBuilder.newBuilder(tn);

    3.使用ColumnFamilyDescriptorBuilder中的of创建列簇描述器对象

    ColumnFamilyDescriptor info = ColumnFamilyDescriptorBuilder.of("info");

    4.使用表描述器对象中的setColumnFamily方法将列簇与表进行关联

    table.setColumnFamily(info);

    5.使用数据库操作对象admin中的createTable方法与表描述器对象中的build方法，创建表

    admin.createTable(table.build());

    1.     @Test
    2.     public void createOneTable()  {
    3.  
    4.         try {
    5.             //先将表名封装成一个TableName的对象
    6.             TableName tn = TableName.valueOf("t_user");
    7.             //TableDescriptorBuilder 类来创建并获取表描述器对象
    8.             TableDescriptorBuilder table = TableDescriptorBuilder.newBuilder(tn);
    9.             //创建列簇描述器对象
    10.             ColumnFamilyDescriptor info = ColumnFamilyDescriptorBuilder.of("info");
    11.             将列簇与表进行关联
    12.             table.setColumnFamily(info);
    13.             //调用方法，创建表
    14.             admin.createTable(table.build());
    15.             System.out.println(tn+"创建成功");
    16.         }catch (Exception e){
    17.             e.printStackTrace();
    18.         }
    19.  
    20.     }

    2.3 删除一张表

    1.先将表名封装成一个TableName的对象

    TableName tn = TableName.valueOf("表名");

    2.判断表是否存在 使用数据库操作对象中的tableExists方法

    admin.tableExists(tn)

    3.先禁用表 使用admin对象调用方法

    admin.disableTable(tn);

    4.使用admin对象调用方法删除表

    admin.deleteTable(tn);

    1.    @Test
    2.     public void dropOneTable(){
    3.         try {
    4.             //先将表名封装成一个TableName的对象
    5.             TableName tn = TableName.valueOf("ppp");
    6.             //判断表是否存在
    7.             if(admin.tableExists(tn)){
    8.                 //先禁用表
    9.                 admin.disableTable(tn);
    10.                 //使用admin对象调用方法删除表
    11.                 //void deleteTable(TableName tableName)
    12.                 admin.deleteTable(tn);
    13.                 System.out.println(tn+"表成功被删除");
    14.             }else {
    15.                 System.out.println(tn+"表不存在！！");
    16.             }
    17.         }catch (Exception e){
    18.             e.printStackTrace();
    19.         }
    20.     }

    2.4 向表中添加一行数据

    1.先将表名封装成一个TableName的对象

    TableName tn = TableName.valueOf("students");

    2.判断表是否存在

    admin.tableExists(tn)

    3.获取表对象  使用数据库连接对象conn中的getTable获取表对象，参数是TableName的对象

    Table students = conn.getTable(tn);

    4.创建put对象，并创建行键

    hbase自带的一个工具类Bytes，可以将字符串转字节数组

    Put put = new Put(Bytes.toBytes("行键信息"));

    5.对put对象进行设置，添加列簇，列名和列值

    public Put add(Cell cell)

    Cell 是一个接口，无法被实例化，使用实现类KeyValue来创建对象

    KeyValue(final byte [] row, final byte [] family, final byte [] qualifier, final byte [] value)

    所以：

    put.add(new KeyValue(Bytes.toBytes("1001"),

    Bytes.toBytes("info"),

    Bytes.toBytes("age"),

    Bytes.toBytes(18)));

    6.需要先将我们添加的列数据封装成一个Put对象

    使用的是表对象students中的put方法，里面传入的是put的对象

    students.put(put);

    1. try {
    2.             //先将表名封装成一个TableName的对象
    3.             TableName tn = TableName.valueOf("students");
    4.             //判断表是否存在
    5.             if(admin.tableExists(tn)){
    6.                 //获取表对象
    7.                 Table students = conn.getTable(tn);
    8.                 //hbase自带的一个工具类Bytes，可以将字符串转字节数组
    9.                 Put put = new Put(Bytes.toBytes("1001"));
    10.                 // //KeyValue(final byte [] row, final byte [] family, final byte [] qualifier, final byte [] value)
    11.                 put.add(new KeyValue(Bytes.toBytes("1001"),
    12.                         Bytes.toBytes("info"),
    13.                         Bytes.toBytes("age"),
    14.                         Bytes.toBytes(18)));
    15.                 students.put(put);
    16.             }else {
    17.                 System.out.println(tn+"表不存在！！");
    18.             }
    19.         }catch (Exception e){
    20.             e.printStackTrace();
    21.         }

    2.5 向表中添加多列数据

    1.先将表名封装成一个TableName的对象

    TableName tn = TableName.valueOf("表名");

    2.创建字符输入缓冲流

    br = new BufferedReader(new FileReader("文件路径"));

    3.判断表是否存在

    admin.tableExists(tn)

    4.循环读取数据

    默认第一行为行键

    String line = null;

    while ((line = br.readLine()) != null) {

    String[] info = line.split(",");

    byte[] rowKey = Bytes.toBytes(info[0]);

    //创建这一行的Put对象

    Put put = new Put(rowKey);

    //第一列作为行键唯一标识，从第二列开始，每一列都要被封装成Put对象

    for (int i = 1; i < info.length; i++) {

    byte[] colName = Bytes.toBytes(info[i]);

    1.    /**
    2.      * 需求：4、如何向一张表中同时添加一批数据
    3.      */
    4.     @Test
    5.     public void putMoreDataToTable(){
    6.         BufferedReader br = null;
    7.         try {
    8.             //先将表名封装成一个TableName的对象
    9.             TableName tn = TableName.valueOf("students");
    10.             //创建字符输入缓冲流
    11.             br = new BufferedReader(new FileReader("data/students.csv"));
    12.  
    13.             String[] colNameArray = {"","name","age","gender","clazz"};
    14.  
    15.             //判断表是否存在
    16.             if(admin.tableExists(tn)){
    17.                 //获取表对象
    18.                 Table students = conn.getTable(tn);
    19.                 //循环读取数据
    20.                 String line = null;
    21.                 while ((line= br.readLine())!=null){
    22.                     String[] info = line.split(",");
    23.                     byte[] rowKey = Bytes.toBytes(info[0]);
    24.                     //创建这一行的Put对象
    25.                     Put put = new Put(rowKey);
    26.                     //第一列作为行键唯一标识，从第二列开始，每一列都要被封装成Put对象
    27.                     for(int i=1;i<info.length;i++){
    28.                         byte[] colName = Bytes.toBytes(info[i]);
    29.                         put.addColumn(Bytes.toBytes("info"),Bytes.toBytes(colNameArray[i]),Bytes.toBytes(info[i]));
    30.                         //添加该列数据
    31.                         students.put(put);
    32.                     }
    33.                 }
    34.  
    35.                 System.out.println("学生表数据添加完毕！！！！");
    36.             }else {
    37.                 System.out.println(tn+"表不存在！！");
    38.             }
    39.  
    40.  
    41.         }catch (Exception e){
    42.             e.printStackTrace();
    43.         }finally {
    44.             if(br!=null){
    45.                 try {
    46.                     br.close();
    47.                 } catch (IOException e) {
    48.                     e.printStackTrace();
    49.                 }
    50.             }
    51.         }
    52.     }

    2.6 获取一条数据

    1.先将表名封装成一个TableName的对象

    TableName tn = TableName.valueOf("表名");

    2.获取表对象  使用数据库连接对象conn中的getTable获取表对象，参数是TableName的对象

    Table students = conn.getTable(tn);

    3.传入行键的字节数组的形式 使用创建Get对象的构造方法

    Get get = new Get(Bytes.toBytes("1500101000"));

    4.得到结果对象 使用表对象中的get方法，传入的是Get的对象

    Result result = table.get(get);

    5.Result类中的常用方法：

    * getRow() ： 获取行键的字节数组形式

    * getValue(byte [] family, byte [] qualifier)： 根据列簇和列名，获取列值的字节数组形式

    * List listCells()：获取所有单元格，单元格中存储了行键，列簇，列名，版本号（时间戳），列值

    6.已知列名的情况下获取

    1.    //获取行键
    2.             String id = Bytes.toString(result.getRow());
    3.             //获取列名
    4.             String name = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("name")));
    5.             String age = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("age")));
    6.             String gender = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("gender")));
    7.             String clazz = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("clazz")));
    8.             System.out.println(id+name+age+gender+clazz);

    7.不知道列名的情况下

    使用的是CellUtil工具类

    增强for循环

    1. //创建单元格
    2.             List<Cell> cells = result.listCells();
    3.             //遍历集合得到每个单元格，获取每个列值
    4.             //增强for循环遍历
    5.             for (Cell cell : cells) {
    6.                 String id = Bytes.toString(CellUtil.cloneRow(cell));
    7.                 String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    8.                 String colValue = Bytes.toString(CellUtil.cloneValue(cell));
    9.                 System.out.println(id+colName+colValue);
    10.             }

    forEach+lambda表达式

    1.    cells.forEach(cell -> {
    2.                 String id = Bytes.toString(CellUtil.cloneRow(cell));
    3.                 String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    4.                 String colValue = Bytes.toString(CellUtil.cloneValue(cell));
    5.                 System.out.println(id+colName+colValue);
    6.             });

    jdk1.8重新特性

    1. //遍历方式4：jdk1.8新特性遍历，转流处理
    2.             cells.stream().map(e->{
    3.                 String id = Bytes.toString(CellUtil.cloneRow(e));
    4.                 String colName = Bytes.toString(CellUtil.cloneQualifier(e));
    5.                 String colValue = Bytes.toString(CellUtil.cloneValue(e));
    6.  
    7.                 return id+colName+colValue;
    8.             }).forEach(System.out::println);

    总体代码

    1.     /**
    2.      * 需求：5、如何获取一条数据
    3.      * get 'students','1500101000'
    4.      */
    5.      @Test
    6.      public void getOneData(){
    7.         try {
    8.             //将表封装成一个TableName对象
    9.             TableName tn = TableName.valueOf("students");
    10.             //获取表对象
    11.             Table table = conn.getTable(tn);
    12.             //传入行键
    13.             Get get = new Get(Bytes.toBytes("1500100979"));
    14.  
    15.             //通过表对象获取结果
    16.             Result result = table.get(get);
    17. //            System.out.println(result);
    18.  
    19.             //获取行键
    20. //            String id = Bytes.toString(result.getRow());
    21.             //获取列名
    22. //            String name = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("name")));
    23. //            String age = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("age")));
    24. //            String gender = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("gender")));
    25. //            String clazz = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("clazz")));
    26. //            System.out.println(id+name+age+gender+clazz);
    27.             //创建单元格
    28.             List<Cell> cells = result.listCells();
    29.             //遍历集合得到每个单元格，获取每个列值
    30.             //增强for循环遍历
    31. //            for (Cell cell : cells) {
    32. //                String id = Bytes.toString(CellUtil.cloneRow(cell));
    33. //                String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    34. //                String colValue = Bytes.toString(CellUtil.cloneValue(cell));
    35. //                System.out.println(id+colName+colValue);
    36. //            }
    37.  
    38.             //遍历方式3：forEach + lambda表达式
    39. //            cells.forEach(cell -> {
    40. //                String id = Bytes.toString(CellUtil.cloneRow(cell));
    41. //                String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    42. //                String colValue = Bytes.toString(CellUtil.cloneValue(cell));
    43. //                System.out.println(id+colName+colValue);
    44. //            });
    45.             //遍历方式4：jdk1.8新特性遍历，转流处理
    46.             cells.stream().map(e->{
    47.                 String id = Bytes.toString(CellUtil.cloneRow(e));
    48.                 String colName = Bytes.toString(CellUtil.cloneQualifier(e));
    49.                 String colValue = Bytes.toString(CellUtil.cloneValue(e));
    50.  
    51.                 return id+colName+colValue;
    52.             }).forEach(System.out::println);

    2.7获取一批数据

    2.7.1 get

    1.先将表名封装成一个TableName的对象

    TableName tn = TableName.valueOf("表名");

    2.获取表对象  使用数据库连接对象conn中的getTable获取表对象，参数是TableName的对象

    Table students = conn.getTable(tn);

    3.创建集合，存储行键，传入行键的字节数组的形式 使用创建Get对象的构造方法

    ArrayList gets = new ArrayList<>();

    for (int i = 1500100001; i <= 1500101000; i++) {

    gets.add(new Get(Bytes.toBytes(String.valueOf(i))));

    }

    这里要转成字符串

    4.得到结果对象集合 使用表对象中的get方法，传入的是Get的对象

    Result[] results = table.get(get);

    5.遍历results 获取每一个result

    for (Result result : results) {

    List cells = result.listCells();

    6.遍历每一个result 获取每一列

    1. for (Result result : results) {
    2.                 List<Cell> cells = result.listCells();
    3.                 if (cells!=null){
    4.                     cells.stream().map(cell -> {
    5.                         String id = Bytes.toString(CellUtil.cloneRow(cell));
    6.                         String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    7.                         String colValue = Bytes.toString(CellUtil.cloneValue(cell));
    8.                         return id+colName+colValue;
    9.                     }).forEach(System.out::println);
    10.                     System.out.println("====================");
    11.                 }else {
    12.                     System.out.println("kong");
    13.                 }
    14.             }
    1.     /**
    2.      * 6、如果获取一批数据 第一种方式
    3.      */
    4.     @Test
    5.     public void getMoreData(){
    6.         try {
    7.             //将表封装成一个TableName对象
    8.             TableName tn = TableName.valueOf("students");
    9.             //获取表对象
    10.             Table table = conn.getTable(tn);
    11.             //创建List集合，存储多个Get对象
    12.             //1500100001 ~ 1500101000
    13.             ArrayList<Get> gets = new ArrayList<>();
    14.             for (int i = 1500100001; i <= 1500101000; i++) {
    15.                 gets.add(new Get(Bytes.toBytes(String.valueOf(i))));
    16.             }
    17.             //default Result[] get(List<Get> gets)
    18.             Result[] results = table.get(gets);
    19.             //1、先遍历results得到每一个result（每一行）
    20.             //2、遍历每一个result中的每一列
    21.             for (Result result : results) {
    22.                 List<Cell> cells = result.listCells();
    23.                 if (cells!=null){
    24.                     cells.stream().map(cell -> {
    25.                         String id = Bytes.toString(CellUtil.cloneRow(cell));
    26.                         String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    27.                         String colValue = Bytes.toString(CellUtil.cloneValue(cell));
    28.                         return id+colName+colValue;
    29.                     }).forEach(System.out::println);
    30.                     System.out.println("====================");
    31.                 }else {
    32.                     System.out.println("kong");
    33.                 }
    34.             }
    35.         }catch (Exception e){
    36.             e.printStackTrace();
    37.         }
    38.     }

    2.7.2 scan

    1.先将表名封装成一个TableName的对象

    TableName tn = TableName.valueOf("表名");

    2.获取表对象  使用数据库连接对象conn中的getTable获取表对象，参数是TableName的对象

    Table students = conn.getTable(tn);

    3.创建scan对象，并设置sacn

    Scan scan = new Scan(); //查询表中的所有行

    scan.withStartRow(Bytes.toBytes("1500100001"));//设置起始行

    // scan.withStopRow(Bytes.toBytes("1500100004"), true);设置末尾行，有true表示包含这一行

    //设置取前几行

    scan.setLimit(10);

    1. /**
    2.      * 7、如果获取一批数据 第二种方式
    3.      * scan 'students' 默认情况下获取表所有数据
    4.      * scan 'students',LIMIT=>3
    5.      */
    6.     @Test
    7.     public void ScanData(){
    8.         try {
    9.             //将表封装成一个TableName对象
    10.             TableName tn = TableName.valueOf("students");
    11.             //获取表对象
    12.             Table table = conn.getTable(tn);
    13.             //创建scan对象
    14.             Scan scan = new Scan();//查询所有行
    15.             //可以设置scan
    16.             scan.withStartRow(Bytes.toBytes("1500100001"));
    17. //            scan.withStopRow(Bytes.toBytes("1500100004"), true);
    18.             //设置前几行
    19.             scan.setLimit(10);
    20.             //创建结果对象
    21.             ResultScanner resultScanner = table.getScanner(scan);
    22.             //获取迭代器对象
    23.             for (Result result : resultScanner) {
    24.                 //不知道列名的情况下
    25.                 //                List<Cell> cells = result.listCells();
    26. //                cells.stream().map(cell -> {
    27. //                    String id = Bytes.toString(CellUtil.cloneRow(cell));
    28. //                    String colName = Bytes.toString(CellUtil.cloneQualifier(cell));
    29. //                    String colValue = Bytes.toString(CellUtil.cloneValue(cell));
    30. //                    return id+colName+colValue;
    31. //                    }).forEach(System.out::println);
    32. //                    System.out.println("====================");
    33.                 //知道列名
    34.                 // 获取行键
    35.                 String id = Bytes.toString(result.getRow());
    36.                 //获取列名
    37.                 String name = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("name")));
    38.                 String age = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("age")));
    39.                 String gender = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("gender")));
    40.                 String clazz = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("clazz")));
    41.                 System.out.println(id + name + age + gender + clazz);
    42.  
    43.             }
    44.         }catch (Exception e){
    45.             e.printStackTrace();
    46.         }
    47.  
    48.     }

    2.8 创建预分表

    1.先将表名封装成一个TableName的对象，使用ableName中的valueOf

    TableName tn = TableName.valueOf("表名");

    2.使用 TableDescriptorBuilder 类来创建并获取表描述器对象

    TableDescriptorBuilder table = TableDescriptorBuilder.newBuilder(tn);

    3.使用ColumnFamilyDescriptorBuilder中的of创建列簇描述器对象

    ColumnFamilyDescriptor info = ColumnFamilyDescriptorBuilder.of("info");

    4.使用表描述器对象中的setColumnFamily方法将列簇与表进行关联

    table.setColumnFamily(info);

    5.创建预分二维数组

    预分点是字节类型

    6.调用另外一个方法，传入表描述器的同时，传入分割点，创建预分region表

    1.  
    2.     /**
    3.      * 需求：7、如何创建预分region表
    4.      * 将来对于某一个RegionServer而言，可能会接收大量的并发请求，超出了该RegionServer承受的压力，有可能会导致该子节点崩溃
    5.      * 如果大量的并发请求查询的数据是多种多种多样的，只不过巧合的是都在一个RegionServer上管理
    6.      * 解决的思路：分散查询的数据到不同的RegionServer上，这样请求也会随着被分散到不同的RegionServer上，就达到了减轻某一个RegionServer压力过大情况，解决了单点故障的问题
    7.      */
    8.     @Test
    9.     public void createPreviewTable(){
    10.         try {
    11.             //先将表名封装成TableName对象
    12.             TableName tn = TableName.valueOf("t_split");
    13.             //创建表描述器对象
    14.             TableDescriptorBuilder table = TableDescriptorBuilder.newBuilder(tn);
    15.             //创建列簇描述器对象
    16.             ColumnFamilyDescriptor info = ColumnFamilyDescriptorBuilder.of("info");
    17.             将列簇与表进行关联
    18.             table.setColumnFamily(info);
    19.             //创建分割键的二维数组
    20.             byte[][] splitKeys = {
    21.                     Bytes.toBytes("f"),
    22.                     Bytes.toBytes("k"),
    23.                     Bytes.toBytes("p")
    24.             };
    25.             //调用方法，创建表
    26.             admin.createTable(table.build(),splitKeys);
    27.             System.out.println(tn+"创建成功");
    28.             
    29.         }catch (Exception e){
    30.             e.printStackTrace();
    31.         }
    32.     }

  • 相关阅读:
    eyb：FastDFS的学习
    LeetCode高频题：设计一个股票推荐系统，自动根据注册用户的关注情况进行推荐，询问时，会推荐那个人多少只他还没有关注的股票
    OpenCV之cvtColor颜色空间转换
    LeetCode——字符串（Java）
    Jmeter介绍以及脚本制作与调试
    OAuth 2.0 （第三方登录）前端流程实现
    【Superset3.0】更全面superset相关--配置邮件报告发送: 附件乱码以及导出文件(截屏图片)中文乱码问题
    leetcode - 780. Reaching Points
    YOLO V3详解
    ChatGLM 实践指南
  • 原文地址：https://blog.csdn.net/weixin_65909965/article/details/137887568