AI 助理
备案控制台
开发者社区 数据库 文章 正文

大数据HBase JavaAPI工具类

2023-09-13 158
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云原生大数据计算服务MaxCompute，500CU*H 100GB 3个月
云原生大数据计算服务 MaxCompute，5000CU*H 100GB 3个月
注册配置 MSE Nacos/ZooKeeper，118元/月
简介： 大数据HBase JavaAPI工具类

1 环境准备

新建项目后在 pom.xml 中添加依赖：

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

2 HBaseAPI

2.1 获取 Configuration 对象

public static Configuration conf;
static{
//使用 HBaseConfiguration 的单例方法实例化
    conf = HBaseConfiguration.create();
    conf.set("hbase.zookeeper.quorum", "192.166.9.102");
    conf.set("hbase.zookeeper.property.clientPort", "2181");
    }
//或者注入到spring
@Configuration
@ConfigurationProperties(prefix = "hbase")
public class HbaseConfiguration {
    private Map<String, String> config = new HashMap<>();
    public Map<String, String> getConfig() {
        return config;
    }
    public void setConfig(Map<String, String> config) {
        this.config = config;
    }
    public org.apache.hadoop.conf.Configuration configuration() {
        org.apache.hadoop.conf.Configuration configuration = HBaseConfiguration.create();
        for(Map.Entry<String, String> map : config.entrySet()){
            configuration.set(map.getKey(), map.getValue());
        }
        return configuration;
    }
    @Bean
    public Admin admin() {
        Admin admin = null;
        try {
            Connection connection = ConnectionFactory.createConnection(configuration());
            admin = connection.getAdmin();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return admin;
    }
}

2.2 判断表是否存在

    /**
     * 判断表是否存在 新版本
     * @param tableName 表名
     * @return true/false
     */
    public boolean isExists(String tableName) {
        boolean tableExists = false;
        try {
            TableName table = TableName.valueOf(tableName);
            tableExists = hbaseAdmin.tableExists(table);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return tableExists;
    }

HBaseAdmin对象都是DDL操作表，

2.3 创建表

public static void createTable(String tableName, String... columnFamily) throws MasterNotRunningException, ZooKeeperConnectionException,IOException{
    HBaseAdmin admin = new HBaseAdmin(conf);
//判断表是否存在
    if(isTableExist(tableName)){
    System.out.println("表" + tableName + "已存在");
//System.exit(0);
    }else{
//创建表属性对象,表名需要转字节
    HTableDescriptor descriptor = new
    HTableDescriptor(TableName.valueOf(tableName));
//创建多个列族
    for(String cf : columnFamily){
//添加列族信息
    descriptor.addFamily(new HColumnDescriptor(cf));
    }
//根据对表的配置，创建表
    admin.createTable(descriptor);
    System.out.println("表" + tableName + "创建成功！");
    }
   }
//封装好的方法，应该在创建的时候先创建最终的方法然后再逐步完善参数，但是熟悉的话可以正着写不过去了公司这都是封装好的知道有这个东西就好
    /*应该先做一个columnFamily的非空判断*/
    public boolean createTable(String tableName, List<String> columnFamily, List<String> keys) {
        if (!isExists(tableName)) {
            try {
                TableName table = TableName.valueOf(tableName);
                HTableDescriptor desc = new HTableDescriptor(table);
                for (String cf : columnFamily) {
                    //创建列族描述器
                    desc.addFamily(new HColumnDescriptor(cf));
                }
                if (keys == null) {
                    hbaseAdmin.createTable(desc);
                } else {
                    byte[][] splitKeys = getSplitKeys(keys);
                    hbaseAdmin.createTable(desc, splitKeys);
                }
                return true;
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println(tableName + "is exists!!!");
            return false;
        }
        return false;
    }

2.4 删除表

public static void dropTable(String tableName) throws
    MasterNotRunningException,
    ZooKeeperConnectionException, IOException{
    HBaseAdmin admin = new HBaseAdmin(conf);
    if(isTableExist(tableName)){
    admin.disableTable(tableName);
    admin.deleteTable(tableName);
    System.out.println("表" + tableName + "删除成功！");
    }else{
    System.out.println("表" + tableName + "不存在！");
    } 
}

命名空间管理(一般不指定命名空间是再default) 命名空间可以被创建、移除、修改。

表和命名空间的隶属关系在在创建表时决定，通过以下格式指定： 当为一张表指定命名空间之后，对表的操作都要加命名空间，否则会找不到表。 相关shell操作如下所示： 创建一个命名空间 根据命名空间创建表 此时命名空间namespace应该存在，否则报错。 删除命名空间

在删除一个命名空间时，该命名空间不能包含任何的表，否则会报错。

修改命名空间 METHOD => ‘set’ ‘PROPERTY_NAME’ => ‘PROPERTY_VALUE’ 显示所有命名空间

2.5 向表中插入数据

public static void addRowData(String tableName, String rowKey,
    String columnFamily, String
    column, String value) throws IOException{
//创建 HTable 对象
    HTable hTable = new HTable(conf, tableName);
//向表中插入数据
    Put put = new Put(Bytes.toBytes(rowKey));
//向 Put 对象中组装数据
    put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column),
    Bytes.toBytes(value));
    hTable.put(put);
    hTable.close();
    System.out.println("插入数据成功");
    }

单条和封装键值对查询数据

    /**
     * 插入数据（单条）
     *
     * @param tableName    表名
     * @param rowKey       rowKey
     * @param columnFamily 列族
     * @param column       列
     * @param value        值
     * @return true/false
     */
    public boolean putData(String tableName, String rowKey, String columnFamily, String column,
                           String value) {
        //键值对
        return putData(tableName, rowKey, columnFamily, Collections.singletonMap(column, value));
    }
    /**
     * 插入数据（批量需要遍历插入数据）
     *
     * @param tableName    表名
     * @param rowKey       rowKey
     * @param columnFamily 列族
     * @param columns      列值
     * @return true/false
     */
    public boolean putData(String tableName, String rowKey, String columnFamily,
                           Map<String, String> columns) {
        try {
            Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
            Put put = new Put(Bytes.toBytes(rowKey));
            for (Map.Entry<String, String> entry : columns.entrySet()) {
                put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(entry.getKey()),
                    Bytes.toBytes(entry.getValue()));
            }
            table.put(put);
            table.close();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

2.6 删除多行数据

public static void deleteMultiRow(String tableName, String... rows)
    throws IOException{
    HTable hTable = new HTable(conf, tableName);
    List<Delete> deleteList = new ArrayList<Delete>();
    for(String row : rows){
    Delete delete = new Delete(Bytes.toBytes(row));
    deleteList.add(delete);
    }
    hTable.delete(deleteList);
    hTable.close();
    }

2.7 获取所有数据

public static void getAllRows(String tableName) throws IOException{
    HTable hTable = new HTable(conf, tableName);
//得到用于扫描 region 的对象
    Scan scan = new Scan();
//使用 HTable 得到 resultcanner 实现类的对象
    ResultScanner resultScanner = hTable.getScanner(scan);
    for(Result result : resultScanner){
    Cell[] cells = result.rawCells();
    for(Cell cell : cells){
//得到 rowkey
    System.out.println(" 行 键 :" +
    Bytes.toString(CellUtil.cloneRow(cell)));
//得到列族
    System.out.println(" 列 族 " +
    Bytes.toString(CellUtil.cloneFamily(cell)));
    System.out.println(" 列 :" +
    Bytes.toString(CellUtil.cloneQualifier(cell)));
    System.out.println(" 值 :" +
    Bytes.toString(CellUtil.cloneValue(cell)));
    } 
  } 
}

2.8 获取某一行数据

public static void getRow(String tableName, String rowKey) throws
    IOException{
    HTable table = new HTable(conf, tableName);
    Get get = new Get(Bytes.toBytes(rowKey));
//get.setMaxVersions();显示所有版本
    //get.setTimeStamp();显示指定时间戳的版本
    Result result = table.get(get);
    for(Cell cell : result.rawCells()){
    System.out.println(" 行 键 :" +Bytes.toString(result.getRow()));
    System.out.println(" 列 族 " +
    Bytes.toString(CellUtil.cloneFamily(cell)));
    System.out.println(" 列 :" +
    Bytes.toString(CellUtil.cloneQualifier(cell)));
    System.out.println(" 值 :" +
    Bytes.toString(CellUtil.cloneValue(cell)));
    System.out.println("时间戳:" + cell.getTimestamp());
    } 
}

2.9 获取某一行指定“列族:列”的数据

public static void getRowQualifier(String tableName, String rowKey,
    String family, String
    qualifier) throws IOException{
    HTable table = new HTable(conf, tableName);
    Get get = new Get(Bytes.toBytes(rowKey));
    get.addColumn(Bytes.toBytes(family),
    Bytes.toBytes(qualifier));
    Result result = table.get(get);
    for(Cell cell : result.rawCells()){
    System.out.println(" 行 键 :" +
    Bytes.toString(result.getRow()));
    System.out.println(" 列 族 " +
    Bytes.toString(CellUtil.cloneFamily(cell)));
    System.out.println(" 列 :" +
    Bytes.toString(CellUtil.cloneQualifier(cell)));
    System.out.println(" 值 :" +
    Bytes.toString(CellUtil.cloneValue(cell)));
    } 
}

3 HBase过滤器过滤数据

测试数据生成:

package demo.filter;
import java.util.ArrayList;
import java.util.List;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Test;
public class DataInit {
  @Test
  public void testCreateTable() throws Exception{
    //指定的配置信息: ZooKeeper
    Configuration conf = new Configuration();
    conf.set("hbase.zookeeper.quorum", "192.168.157.111");
    //创建一个HBase客户端: HBaseAdmin
    HBaseAdmin admin = new HBaseAdmin(conf);
    //创建一个表的描述符: 表名
    HTableDescriptor hd = new HTableDescriptor(TableName.valueOf("emp"));
    //创建列族描述符
    HColumnDescriptor hcd1 = new HColumnDescriptor("empinfo");
    //加入列族
    hd.addFamily(hcd1);
    //创建表
    admin.createTable(hd);
    //关闭客户端
    admin.close();
  }
  @Test
  public void testPutData() throws Exception{
    //指定的配置信息: ZooKeeper
    Configuration conf = new Configuration();
    conf.set("hbase.zookeeper.quorum", "192.168.157.111");
    //客户端
    HTable table = new HTable(conf, "emp");
    //第一条数据
    Put put1 = new Put(Bytes.toBytes("7369"));
    put1.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("SMITH"));
    Put put2 = new Put(Bytes.toBytes("7369"));
    put2.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("800"));
    //第二条数据
    Put put3 = new Put(Bytes.toBytes("7499"));
    put3.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("ALLEN"));
    Put put4 = new Put(Bytes.toBytes("7499"));
    put4.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("1600"));    
    //第三条数据
    Put put5 = new Put(Bytes.toBytes("7521"));
    put5.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("WARD"));
    Put put6 = new Put(Bytes.toBytes("7521"));
    put6.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("1250"));    
    //第四条数据
    Put put7 = new Put(Bytes.toBytes("7566"));
    put7.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("JONES"));
    Put put8 = new Put(Bytes.toBytes("7566"));
    put8.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("2975"));    
    //第五条数据
    Put put9 = new Put(Bytes.toBytes("7654"));
    put9.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("MARTIN"));
    Put put10 = new Put(Bytes.toBytes("7654"));
    put10.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("1250"));
    //第六条数据
    Put put11 = new Put(Bytes.toBytes("7698"));
    put11.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("BLAKE"));
    Put put12 = new Put(Bytes.toBytes("7698"));
    put12.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("2850"));
    //第七条数据
    Put put13 = new Put(Bytes.toBytes("7782"));
    put13.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("CLARK"));
    Put put14 = new Put(Bytes.toBytes("7782"));
    put14.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("2450"));
    //第八条数据
    Put put15 = new Put(Bytes.toBytes("7788"));
    put15.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("SCOTT"));
    Put put16 = new Put(Bytes.toBytes("7788"));
    put16.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("3000"));   
    //第九条数据
    Put put17 = new Put(Bytes.toBytes("7839"));
    put17.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("KING"));
    Put put18 = new Put(Bytes.toBytes("7839"));
    put18.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("5000")); 
    //第十条数据
    Put put19 = new Put(Bytes.toBytes("7844"));
    put19.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("TURNER"));
    Put put20 = new Put(Bytes.toBytes("7844"));
    put20.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("1500")); 
    //第十一条数据
    Put put21 = new Put(Bytes.toBytes("7876"));
    put21.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("ADAMS"));
    Put put22 = new Put(Bytes.toBytes("7876"));
    put22.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("1100")); 
    //第十二条数据
    Put put23 = new Put(Bytes.toBytes("7900"));
    put23.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("JAMES"));
    Put put24 = new Put(Bytes.toBytes("7900"));
    put24.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("950"));
    //第十三条数据
    Put put25 = new Put(Bytes.toBytes("7902"));
    put25.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("FORD"));
    Put put26 = new Put(Bytes.toBytes("7902"));
    put26.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("3000"));
    //第十四条数据
    Put put27 = new Put(Bytes.toBytes("7934"));
    put27.add(Bytes.toBytes("empinfo"), Bytes.toBytes("ename"), Bytes.toBytes("MILLER"));
    Put put28 = new Put(Bytes.toBytes("7934"));
    put28.add(Bytes.toBytes("empinfo"), Bytes.toBytes("sal"), Bytes.toBytes("1300"));
    //构造List
    List<Put> list = new ArrayList<Put>();
    list.add(put1);
    list.add(put2);
    list.add(put3);
    list.add(put4);
    list.add(put5);
    list.add(put6);
    list.add(put7);
    list.add(put8);
    list.add(put9);
    list.add(put10);
    list.add(put11);
    list.add(put12);
    list.add(put13);
    list.add(put14);
    list.add(put15);
    list.add(put16);
    list.add(put17);
    list.add(put18);
    list.add(put19);
    list.add(put20);
    list.add(put21);
    list.add(put22);
    list.add(put23);
    list.add(put24);
    list.add(put25);
    list.add(put26);
    list.add(put27);
    list.add(put28);    
    //插入数据
    table.put(list);
    table.close();    
  }
}

package demo.filter;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.filter.ColumnPrefixFilter;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.FilterList.Operator;
import org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter;
import org.apache.hadoop.hbase.filter.RegexStringComparator;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Test;
public class FilterDemo {
//1、列值过滤器：根据列的值进行查询 where sal=3000
  @Test
  public void testSingleColumnValueFilter() throws Exception{
    //指定的配置信息: ZooKeeper
    Configuration conf = new Configuration();
    conf.set("hbase.zookeeper.quorum", "192.168.157.111");
    //客户端
    HTable table = new HTable(conf, "emp");
    //创建一个扫描器和列值过滤器
    Scan scan = new Scan();
    SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes("empinfo"),     //列族
                                   Bytes.toBytes("sal"),     //列
                                                             CompareOp.EQUAL,  //比较运算符
                                                             Bytes.toBytes("3000"));
    scan.setFilter(filter);
    //查询数据
    ResultScanner rs = table .getScanner(scan);
    for(Result r:rs) {
      //取出数据
      String name = Bytes.toString(r.getValue(Bytes.toBytes("empinfo"), Bytes.toBytes("ename")));
      System.out.println(name);     
    }
    table.close();
  }
//2、列名前缀过滤器：查询指定的列，查询员工的姓名  select ename from emp;
  @Test
  public void testColumnPrefixFilter() throws Exception{
    //指定的配置信息: ZooKeeper
    Configuration conf = new Configuration();
    conf.set("hbase.zookeeper.quorum", "192.168.157.111");
    //客户端
    HTable table = new HTable(conf, "emp");
    //创建一个扫描器和列名前缀过滤器
    Scan scan = new Scan();
    ColumnPrefixFilter filter = new ColumnPrefixFilter(Bytes.toBytes("ename"));
    scan.setFilter(filter);
    //查询数据
    ResultScanner rs = table .getScanner(scan);
    for(Result r:rs) {
      //取出数据
      String name = Bytes.toString(r.getValue(Bytes.toBytes("empinfo"), Bytes.toBytes("ename")));
      System.out.println(name);     
    }   
    table.close();
  }
//3、多个列名前缀过滤器：查询指定多个列，查询员工的姓名和薪水：select ename,sal from emp;
  @Test
  public void testMultipleColumnPrefixFilter() throws Exception{
    //指定的配置信息: ZooKeeper
    Configuration conf = new Configuration();
    conf.set("hbase.zookeeper.quorum", "192.168.157.111");
    //客户端
    HTable table = new HTable(conf, "emp");
    //创建一个扫描器和多个列名前缀过滤器
    Scan scan = new Scan();
    byte[][] prefix = {Bytes.toBytes("ename"),Bytes.toBytes("sal")};
    MultipleColumnPrefixFilter filter = new MultipleColumnPrefixFilter(prefix);
    scan.setFilter(filter);
    //查询数据
    ResultScanner rs = table .getScanner(scan);
    for(Result r:rs) {
      //取出数据
      String name = Bytes.toString(r.getValue(Bytes.toBytes("empinfo"), Bytes.toBytes("ename")));
      String sal = Bytes.toString(r.getValue(Bytes.toBytes("empinfo"), Bytes.toBytes("sal")));
      System.out.println(name+"\t"+sal);      
    }       
    table.close();
  }
//4、Rowkey过滤器：通过行键进行查询
  @Test
  public void testRowFilter() throws Exception{
    //指定的配置信息: ZooKeeper
    Configuration conf = new Configuration();
    conf.set("hbase.zookeeper.quorum", "192.168.157.111");
    //客户端
    HTable table = new HTable(conf, "emp");
    //创建一个扫描器
    Scan scan = new Scan();
    //定义一个行键过滤器
    //查询行键是7839的员工信息
    RowFilter filter = new RowFilter(CompareOp.EQUAL,   //比较运算符 
                                 new RegexStringComparator("7839"));  //使用正则表达式表示值
    scan.setFilter(filter);
    //查询数据
    ResultScanner rs = table .getScanner(scan);
    for(Result r:rs) {
      //取出数据
      String name = Bytes.toString(r.getValue(Bytes.toBytes("empinfo"), Bytes.toBytes("ename")));
      String sal = Bytes.toString(r.getValue(Bytes.toBytes("empinfo"), Bytes.toBytes("sal")));
      System.out.println(name+"\t"+sal);      
    } 
    table.close();
  }
//5、查询中，组合多个过滤器
  @Test
  public void testFilters() throws Exception{
    /*
     * 查询工资等于3000的员工姓名
     * 1、列值过滤器，得到工资等于3000
     * 2、列名前缀的过滤器，得到姓名
     */
    //指定的配置信息: ZooKeeper
    Configuration conf = new Configuration();
    conf.set("hbase.zookeeper.quorum", "192.168.157.111");
    //客户端
    HTable table = new HTable(conf, "emp");
    //创建一个扫描器
    Scan scan = new Scan();
    //第一个过滤器  列值过滤器，得到工资等于3000
    SingleColumnValueFilter filter1 = new SingleColumnValueFilter(Bytes.toBytes("empinfo"),     //列族
                                   Bytes.toBytes("sal"),     //列
                                          CompareOp.EQUAL,  //比较运算符
                                          Bytes.toBytes("3000"));   
    //第二个过滤器：列名前缀过滤器，得到员工的姓名
    ColumnPrefixFilter filter2 = new ColumnPrefixFilter(Bytes.toBytes("ename"));
    //Operator.MUST_PASS_ALL：相当于是and
    //Operator.MUST_PASS_ONE：相当于是or
    FilterList list = new FilterList(Operator.MUST_PASS_ALL);
    list.addFilter(filter1);
    list.addFilter(filter2);
    scan.setFilter(list);
    //查询数据
    ResultScanner rs = table .getScanner(scan);
    for(Result r:rs) {
      //取出数据
      String name = Bytes.toString(r.getValue(Bytes.toBytes("empinfo"), Bytes.toBytes("ename")));
      String sal = Bytes.toString(r.getValue(Bytes.toBytes("empinfo"), Bytes.toBytes("sal")));
      System.out.println(name+"\t"+sal);      
    }     
    table.close();
  }
}
文章标签：
云原生大数据计算服务 MaxCompute
云数据库HBase版
微服务引擎
Hbase
分布式数据库
大数据
Shell
SQL
关键词：
云原生大数据计算服务 MaxCompute javaapi
云数据库HBase版javaapi
云数据库HBase版大数据
大数据云数据库HBase版
云原生大数据计算服务 MaxCompute hbase
相关实践学习
基于MaxCompute的热门话题分析
本实验围绕社交用户发布的文章做了详尽的分析，通过分析能得到用户群体年龄分布，性别分布，地理位置分布，以及热门话题的热度。
SaaS 模式云数据仓库必修课
本课程由阿里云开发者社区和阿里云大数据团队共同出品，是SaaS模式云原生数据仓库领导者MaxCompute核心课程。本课程由阿里云资深产品和技术专家们从概念到方法，从场景到实践，体系化的将阿里巴巴飞天大数据平台10多年的经过验证的方法与实践深入浅出的讲给开发者们。帮助大数据开发者快速了解并掌握SaaS模式的云原生的数据仓库，助力开发者学习了解先进的技术栈，并能在实际业务中敏捷的进行大数据分析，赋能企业业务。 通过本课程可以了解SaaS模式云原生数据仓库领导者MaxCompute核心功能及典型适用场景，可应用MaxCompute实现数仓搭建，快速进行大数据分析。适合大数据工程师、大数据分析师 大量数据需要处理、存储和管理，需要搭建数据仓库？学它！ 没有足够人员和经验来运维大数据平台，不想自建IDC买机器，需要免运维的大数据平台？会SQL就等于会大数据？学它！ 想知道大数据用得对不对，想用更少的钱得到持续演进的数仓能力？获得极致弹性的计算资源和更好的性能，以及持续保护数据安全的生产环境？学它！ 想要获得灵活的分析能力，快速洞察数据规律特征？想要兼得数据湖的灵活性与数据仓库的成长性？学它！ 出品人：阿里云大数据产品及研发团队专家 产品 MaxCompute 官网 https://www.aliyun.com/product/odps&nbsp;
赵广陆
目录
相关文章
武子康
|
3月前
|
消息中间件 监控 数据可视化
大数据-79 Kafka 集群模式 集群监控方案 JavaAPI获取集群指标 可视化监控集群方案： jconsole、Kafka Eagle
大数据-79 Kafka 集群模式 集群监控方案 JavaAPI获取集群指标 可视化监控集群方案： jconsole、Kafka Eagle
武子康
119 2
土木林森
|
5月前
|
Java 大数据 分布式数据库
Spring Boot 与 HBase 的完美融合：探索高效大数据应用开发的新途径
【8月更文挑战第29天】Spring Boot是一款广受好评的微服务框架，以其便捷的开发体验著称。HBase则是一个高性能的大数据分布式数据库系统。结合两者，可极大简化HBase应用开发。本文将对比传统方式与Spring Boot集成HBase的区别，展示如何在Spring Boot中优雅实现HBase功能，并提供示例代码。从依赖管理、连接配置、表操作到数据访问，Spring Boot均能显著减少工作量，提升代码可读性和可维护性，使开发者更专注业务逻辑。
土木林森
308 1
武子康
|
3月前
|
消息中间件 大数据 Kafka
大数据-77 Kafka 高级特性-稳定性-延时队列、重试队列 概念学习 JavaAPI实现（二）
大数据-77 Kafka 高级特性-稳定性-延时队列、重试队列 概念学习 JavaAPI实现（二）
武子康
39 2
武子康
|
3月前
|
SQL 分布式计算 Hadoop
Hadoop-37 HBase集群 JavaAPI 操作3台云服务器 POM 实现增删改查调用操作 列族信息 扫描全表
Hadoop-37 HBase集群 JavaAPI 操作3台云服务器 POM 实现增删改查调用操作 列族信息 扫描全表
武子康
42 3
武子康
|
3月前
|
消息中间件 NoSQL 大数据
大数据-77 Kafka 高级特性-稳定性-延时队列、重试队列 概念学习 JavaAPI实现（一）
大数据-77 Kafka 高级特性-稳定性-延时队列、重试队列 概念学习 JavaAPI实现（一）
武子康
48 1
武子康
|
3月前
|
消息中间件 大数据 Java
大数据-55 Kafka sh脚本使用 与 JavaAPI使用 topics.sh producer.sh consumer.sh kafka-clients
大数据-55 Kafka sh脚本使用 与 JavaAPI使用 topics.sh producer.sh consumer.sh kafka-clients
武子康
38 2
喜欢猪猪
|
4月前
|
存储 分布式计算 分布式数据库
深入理解Apache HBase：构建大数据时代的基石
在大数据时代，数据的存储和管理成为了企业面临的一大挑战。随着数据量的急剧增长和数据结构的多样化，传统的关系型数据库（如RDBMS）逐渐显现出局限性。
喜欢猪猪
594 12
土木林森
|
5月前
|
分布式计算 大数据 分布式数据库
"揭秘HBase MapReduce高效数据处理秘诀：四步实战攻略，让你轻松玩转大数据分析！"
【8月更文挑战第17天】大数据时代，HBase以高性能、可扩展性成为关键的数据存储解决方案。结合MapReduce分布式计算框架，能高效处理HBase中的大规模数据。本文通过实例展示如何配置HBase集群、编写Map和Reduce函数，以及运行MapReduce作业来计算HBase某列的平均值。此过程不仅限于简单的统计分析，还可扩展至更复杂的数据处理任务，为企业提供强有力的大数据技术支持。
土木林森
89 1
1941623231718325
|
6月前
|
存储 NoSQL 大数据
大数据存储：HBase与Cassandra的对比
【7月更文挑战第16天】HBase和Cassandra作为两种流行的分布式NoSQL数据库，在数据模型、一致性模型、数据分布、查询语言和性能等方面各有千秋。HBase适用于需要强一致性和与Hadoop生态系统集成的场景，如大规模数据处理和分析。而Cassandra则更适合需要高可用性和灵活查询能力的场景，如分布式计算、云计算和大数据应用等。在实际应用中，选择哪种数据库取决于具体的需求和场景。希望本文的对比分析能够帮助读者更好地理解这两种数据库，并做出明智的选择。
1941623231718325
432 1
weixin_836869520
|
6月前
|
存储 Java 分布式数据库
使用Spring Boot和HBase实现大数据存储
使用Spring Boot和HBase实现大数据存储
weixin_836869520
374 1

热门文章

最新文章

  • 1
    DataWorks产品测评|基于DataWorks和MaxCompute产品组合实现用户画像分析
  • 2
    针对MaxCompute经典网络域名下线，Dataphin应对策略的公告
  • 3
    深入探索人工智能与大数据的融合之路
  • 4
    大数据时代的引擎：大数据架构随记
  • 5
    大数据& AI 产品月刊【2024年11月】
  • 6
    在大数据时代，高维数据处理成为难题，主成分分析（PCA）作为一种有效的数据降维技术，通过线性变换将数据投影到新的坐标系
  • 7
    智能化运维：AI与大数据在IT运维中的应用探索####
  • 8
    DataWorks产品评测：大数据开发治理平台的最佳实践与体验
  • 9
    聊聊DataWorks——这个一站式智能大数据开发治理平台
  • 10
    用户画像分析（MaxCompute简化版）
  • 1
    Hbase与MySQL对比，区别是什么？
    330
  • 2
    【HBase入门与实战】一文搞懂HBase!
    1067
  • 3
    实现HBase表和RDB表的转化(附Java源码资源)
    63
  • 4
    Ganglia监控Hadoop与HBase集群
    72
  • 5
    基于Hadoop分布式数据库HBase1.0部署及使用
    144
  • 6
    Hbase集群搭建
    135
  • 7
    HBase分布式数据库关键技术与实战：面试经验与必备知识点解析
    482
  • 8
    bigdata-27-HBase架构与概念
    114
  • 9
    bigdata-28-HBase基本调优策略
    96
  • 10
    Linux安装HBase的详细教程及常用方法
    761

    • 相关课程

    更多
  • 大数据知识图谱系列—如何选择合适的OLAP引擎进行数据湖分析
  • 大数据知识图谱—钱大妈数据中台建设最佳实践
  • HBase入门与实战
  • 云数据库HBase版使用教程
  • HBase入门教程
  • 分布式数据库 HBase 快速入门

    • 相关电子书

    更多
  • 大数据时代的存储 ——HBase的实践与探索
  • Hbase在滴滴出行的应用场景和最佳实践
  • 阿里云HBase主备双活

    • 相关实验场景

    更多
  • 基于OpenSearch向量检索版和MaxCompute快速搭建图搜服务
  • 倚天大数据电商数据分析快速实践
  • 玩转MaxCompute SQL! 30分钟搞定数据分析挖掘
  • 使用内置公开数据集快速体验MaxCompute
  • 基于MaxCompute的热门话题分析
  • 实时数据及离线数据上云方案
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月