HBase篇--HBase操作Api和Java操作Hbase相关Api

JAVA API连接Hbase操作 新手小白,第一篇帖子是有关Hadoop下如何实现Java API连接Hbase,如有错误欢迎指正讨论。 一、安装jdk、eclipse并配置环境变量 (一)安装jdk 从Oracle官网下载对应版本JDK,下载后查看安装包。 根据教程将jdk解压到/usr/lib/jvm文件夹时发现,/hadoop/lib/jvm下为openjdk,大多数LINUX发行版本里,内置或者通过软件源安装JDK的话,都是安装的openjdk,openjdk是jdk的开放原始码版本,以GPL协议的形式放出。 因此openjdk只 阅读详情

========================================================

声明:由于不同平台源码阅读格式不一致,所以获取更多阅读体验!!

请关注本人博客园地址:http://www.cnblogs.com/LHWorldBlog/p/8297706.html

个人网站地址:http://www.lhworldblog.com/2018/01/18/hbase

==================================================================

一.前述。

Hbase shell启动命令窗口,然后再Hbase shell中对应的api命令如下。

二.说明

Hbase shell中删除键是空格+Ctrl键。

三.代码

1.封装所有的API

package com.sxt.hbase;

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HConnection;
import org.apache.hadoop.hbase.client.HConnectionManager;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.HTableInterface;
import org.apache.hadoop.hbase.client.HTablePool;
import org.apache.hadoop.hbase.client.Put;
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.BinaryComparator;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.PrefixFilter;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.filter.SubstringComparator;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Test;


public class HBaseDAOImp {

    HConnection hTablePool = null;
    static Configuration conf =null;
    public HBaseDAOImp()
    {
         conf = new Configuration();
        String zk_list = "node1,node2,node3";//只指定zookeeper集群即可,因为在zookeeper中存贮所有Region的寻址入口,而客户端只需要知道需要存储的具体位置后,
 //即可请求对应的regionServer上去写入数据。
        conf.set("hbase.zookeeper.quorum", zk_list);
        try {
            hTablePool = HConnectionManager.createConnection(conf) ;//申请一个HTablePool可以解决HTable存在的线程不安全问题,
  // 同时通过维护固定数量的HTable对象,能够在程序运行期间复用这些HTable资源对象
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void save(Put put, String tableName) {
        // TODO Auto-generated method stub
        HTableInterface table = null;
        try {
            table = hTablePool.getTable(tableName) ;
            table.put(put) ;
            
        } catch (Exception e) {
            e.printStackTrace() ;
        }finally{
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 插入一个cell
     * @param tableName
     * @param rowKey
     * @param family
     * @param quailifer
     * @param value
     */
    public void insert(String tableName, String rowKey, String family,
            String quailifer, String value) {
        // TODO Auto-generated method stub
        HTableInterface table = null;
        try {
            table = hTablePool.getTable(tableName) ;//针对哪张表操作
            Put put = new Put(rowKey.getBytes());//增添数据通过Put对象操作,添加一条rowkey
            put.add(family.getBytes(), quailifer.getBytes(), value.getBytes()) ;//添加哪个列族,列,value值。
            table.put(put);//放置到hbase的对象中去。
        } catch (Exception e) {
            e.printStackTrace();
        }finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 在一个列族下插入多个单元格
     * @param tableName
     * @param rowKey
     * @param family
     * @param quailifer
     * @param value
     */
    public void insert(String tableName,String rowKey,String family,String quailifer[],String value[])
    {
        HTableInterface table = null;
        try {
            table = hTablePool.getTable(tableName) ;
            Put put = new Put(rowKey.getBytes());
            // 批量添加
            for (int i = 0; i < quailifer.length; i++) {
                String col = quailifer[i];
                String val = value[i];
                put.add(family.getBytes(), col.getBytes(), val.getBytes());
            }
            table.put(put);
        } catch (Exception e) {
            e.printStackTrace();
        }finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public void save(List<Put> Put, String tableName) {
        // TODO Auto-generated method stub
        HTableInterface table = null;
        try {
            table = hTablePool.getTable(tableName) ;
            table.put(Put) ;
        }
        catch (Exception e) {
            // TODO: handle exception
        }finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }


    public Result getOneRow(String tableName, String rowKey) {
        // TODO Auto-generated method stub
        HTableInterface table = null;
        Result rsResult = null;
        try {
            table = hTablePool.getTable(tableName) ;
            Get get = new Get(rowKey.getBytes()) ;/通过get获取一条数据
            rsResult = table.get(get) ;//返回一个result对象
        } catch (Exception e) {
            e.printStackTrace() ;
        }
        finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return rsResult;
    }
    
    /**
     * 最常用的方法,优化查询
     * 查询一行数据,
     * @param tableName
     * @param rowKey
     * @param cols
     * @return
     */
    public Result getOneRowAndMultiColumn(String tableName, String rowKey,String[] cols) {
        // TODO Auto-generated method stub
        HTableInterface table = null;
        Result rsResult = null;
        try {
            table = hTablePool.getTable(tableName) ;
            Get get = new Get(rowKey.getBytes()) ;
            for (int i = 0; i < cols.length; i++) {
                get.addColumn("cf".getBytes(), cols[i].getBytes()) ;
            }
            rsResult = table.get(get) ;
        } catch (Exception e) {
            e.printStackTrace() ;
        }
        finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return rsResult;
    }

    
    public List<Result> getRows(String tableName, String rowKeyLike) {
        // TODO Auto-generated method stub
        HTableInterface table = null;
        List<Result> list = null;
        try {
            FilterList fl = new FilterList(FilterList.Operator.MUST_PASS_ALL);
            table = hTablePool.getTable(tableName) ;
            PrefixFilter filter = new PrefixFilter(rowKeyLike.getBytes());
            SingleColumnValueFilter filter1 = new SingleColumnValueFilter(
                      "order".getBytes(),
                      "order_type".getBytes(),
                      CompareOp.EQUAL,
                      Bytes.toBytes("1")
                      );
            fl.addFilter(filter);
            fl.addFilter(filter1);
            Scan scan = new Scan();
            scan.setFilter(fl);
            ResultScanner scanner = table.getScanner(scan) ;
            list = new ArrayList<Result>() ;
            for (Result rs : scanner) {
                list.add(rs) ;
            }
        } catch (Exception e) {
            e.printStackTrace() ;
        }
        finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return list;
    }
    
    
    public List<Result> getRows(String tableName, String rowKeyLike ,String cols[]) {
        // TODO Auto-generated method stub
        HTableInterface table = null;
        List<Result> list = null;
        try {
            table = hTablePool.getTable(tableName) ;
            PrefixFilter filter = new PrefixFilter(rowKeyLike.getBytes());
            
            Scan scan = new Scan();
            for (int i = 0; i < cols.length; i++) {
                scan.addColumn("cf".getBytes(), cols[i].getBytes()) ;
            }
            scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan) ;
            list = new ArrayList<Result>() ;
            for (Result rs : scanner) {
                list.add(rs) ;
            }
        } catch (Exception e) {
            e.printStackTrace() ;
        }
        finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return list;
    }
    
    public List<Result> getRowsByOneKey(String tableName, String rowKeyLike ,String cols[]) {
        // TODO Auto-generated method stub
        HTableInterface table = null;
        List<Result> list = null;
        try {
            table = hTablePool.getTable(tableName) ;
            PrefixFilter filter = new PrefixFilter(rowKeyLike.getBytes());
            
            Scan scan = new Scan();
            for (int i = 0; i < cols.length; i++) {
                scan.addColumn("cf".getBytes(), cols[i].getBytes()) ;
            }
            scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan) ;
            list = new ArrayList<Result>() ;
            for (Result rs : scanner) {
                list.add(rs) ;
            }
        } catch (Exception e) {
            e.printStackTrace() ;
        }
        finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return list;
    }
    
    /**
     * 范围查询
     * @param tableName
     * @param startRow
     * @param stopRow
     * @return
     */
    public List<Result> getRows(String tableName,String startRow,String stopRow)
    {
        HTableInterface table = null;
        List<Result> list = null;
        try {
            table = hTablePool.getTable(tableName) ;
            Scan scan = new Scan() ;
            scan.setStartRow(startRow.getBytes()) ;
            scan.setStopRow(stopRow.getBytes()) ;
            ResultScanner scanner = table.getScanner(scan) ;
            list = new ArrayList<Result>() ;
            for (Result rsResult : scanner) {
                list.add(rsResult) ;
            }
            
        }catch (Exception e) {
            e.printStackTrace() ;
        }
        finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return list;
    }
    
    
    public void deleteRecords(String tableName, String rowKeyLike){
        HTableInterface table = null;
        try {
            table = hTablePool.getTable(tableName) ;
            PrefixFilter filter = new PrefixFilter(rowKeyLike.getBytes());
            Scan scan = new Scan();
            scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan) ;
            List<Delete> list = new ArrayList<Delete>() ;
            for (Result rs : scanner) {
                Delete del = new Delete(rs.getRow());
                list.add(del) ;
            }
            table.delete(list);
        }
        catch (Exception e) {
            e.printStackTrace() ;
        }
        finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
    
    public void deleteCell(String tableName, String rowkey,String cf,String column){
        HTableInterface table = null;
        try {
            table = hTablePool.getTable(tableName) ;
            Delete del = new Delete(rowkey.getBytes());
            del.deleteColumn(cf.getBytes(), column.getBytes());
            table.delete(del);
        }
        catch (Exception e) {
            e.printStackTrace() ;
        }
        finally
        {
            try {
                table.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
    
    public   void createTable(String tableName, String[] columnFamilys){
        try {
            // admin 对象
            HBaseAdmin admin = new HBaseAdmin(conf);
            if (admin.tableExists(tableName)) {
                System.err.println("此表,已存在!");
            } else {
                HTableDescriptor tableDesc = new HTableDescriptor(
                        TableName.valueOf(tableName));

                for (String columnFamily : columnFamilys) {
                    tableDesc.addFamily(new HColumnDescriptor(columnFamily));
                }

                admin.createTable(tableDesc);
                System.err.println("建表成功!");

            }
            admin.close();// 关闭释放资源
        } catch (MasterNotRunningException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ZooKeeperConnectionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    /**
     * 删除一个表
     * 
     * @param tableName
     *            删除的表名
     * */
    public   void deleteTable(String tableName)   {
        try {
            HBaseAdmin admin = new HBaseAdmin(conf);
            if (admin.tableExists(tableName)) {
                admin.disableTable(tableName);// 禁用表
                admin.deleteTable(tableName);// 删除表
                System.err.println("删除表成功!");
            } else {
                System.err.println("删除的表不存在!");
            }
            admin.close();
        } catch (MasterNotRunningException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ZooKeeperConnectionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
    /**
     * 查询表中所有行
     * @param tablename
    */
    public void scaner(String tablename) {
    try {
            HTable table =new HTable(conf, tablename);
            Scan s =new Scan();
//            s.addColumn(family, qualifier)
//            s.addColumn(family, qualifier)
            ResultScanner rs = table.getScanner(s);
    for (Result r : rs) {
                
           for(Cell cell:r.rawCells()){   
                System.out.println("RowName:"+new String(CellUtil.cloneRow(cell))+" ");
                System.out.println("Timetamp:"+cell.getTimestamp()+" ");
                System.out.println("column Family:"+new String(CellUtil.cloneFamily(cell))+" ");
                System.out.println("row Name:"+new String(CellUtil.cloneQualifier(cell))+" ");
                System.out.println("value:"+new String(CellUtil.cloneValue(cell))+" ");
               }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void scanerByColumn(String tablename) {
        
        try {
            HTable table =new HTable(conf, tablename);
            Scan s =new Scan();
            s.addColumn("cf".getBytes(), "201504052237".getBytes());
            s.addColumn("cf".getBytes(), "201504052237".getBytes());
            ResultScanner rs = table.getScanner(s);
            for (Result r : rs) {
                
                for(Cell cell:r.rawCells()){   
                    System.out.println("RowName:"+new String(CellUtil.cloneRow(cell))+" ");
                    System.out.println("Timetamp:"+cell.getTimestamp()+" ");
                    System.out.println("column Family:"+new String(CellUtil.cloneFamily(cell))+" ");
                    System.out.println("row Name:"+new String(CellUtil.cloneQualifier(cell))+" ");
                    System.out.println("value:"+new String(CellUtil.cloneValue(cell))+" ");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        

        
        
//        创建表
//        String tableName="test";
//        String cfs[] = {"cf"};
//        dao.createTable(tableName,cfs);
        
//        存入一条数据
//        Put put = new Put("bjsxt".getBytes());
//        put.add("cf".getBytes(), "name".getBytes(), "cai10".getBytes()) ;
//        dao.save(put, "test") ;

//        插入多列数据
//        Put put = new Put("bjsxt".getBytes());
//        List<Put> list = new ArrayList<Put>();
//        put.add("cf".getBytes(), "addr".getBytes(), "shanghai1".getBytes()) ;
//        put.add("cf".getBytes(), "age".getBytes(), "30".getBytes()) ;
//        put.add("cf".getBytes(), "tel".getBytes(), "13889891818".getBytes()) ;
//        list.add(put) ;
//        dao.save(list, "test");
        
//        插入单行数据
//        dao.insert("test", "testrow", "cf", "age", "35") ;
//        dao.insert("test", "testrow", "cf", "cardid", "12312312335") ;
//        dao.insert("test", "testrow", "cf", "tel", "13512312345") ;
        
        
        
//        List<Result> list = dao.getRows("test", "testrow",new String[]{"age"}) ;
//        for(Result rs : list)
//        {
//            for(Cell cell:rs.rawCells()){   
//                System.out.println("RowName:"+new String(CellUtil.cloneRow(cell))+" ");
//                System.out.println("Timetamp:"+cell.getTimestamp()+" ");
//                System.out.println("column Family:"+new String(CellUtil.cloneFamily(cell))+" ");
//                System.out.println("row Name:"+new String(CellUtil.cloneQualifier(cell))+" ");
//                System.out.println("value:"+new String(CellUtil.cloneValue(cell))+" ");
//               }
//        }
        
//        Result rs = dao.getOneRow("test", "testrow");
//         System.out.println(new String(rs.getValue("cf".getBytes(), "age".getBytes())));
        
//        Result rs = dao.getOneRowAndMultiColumn("cell_monitor_table", "29448-513332015-04-05", new String[]{"201504052236","201504052237"});
//        for(Cell cell:rs.rawCells()){   
//            System.out.println("RowName:"+new String(CellUtil.cloneRow(cell))+" ");
//            System.out.println("Timetamp:"+cell.getTimestamp()+" ");
//            System.out.println("column Family:"+new String(CellUtil.cloneFamily(cell))+" ");
//            System.out.println("row Name:"+new String(CellUtil.cloneQualifier(cell))+" ");
//            System.out.println("value:"+new String(CellUtil.cloneValue(cell))+" ");
//           }
        
//        dao.deleteTable("cell_monitor_table");
//        创建表
        String tableName="cell_monitor_table";
        String cfs[] = {"cf"};
//        dao.createTable(tableName,cfs);
    }
    
    
      public static void testRowFilter(String tableName){
             try {
                  HTable table =new HTable(conf, tableName);
                Scan scan = new Scan();
                scan.addColumn(Bytes.toBytes("column1"),Bytes.toBytes("qqqq"));
                Filter filter1 = new RowFilter(CompareOp.LESS_OR_EQUAL,new BinaryComparator(Bytes.toBytes("laoxia157")));
                scan.setFilter(filter1);
                ResultScanner scanner1 = table.getScanner(scan);
                for (Result res : scanner1) {
                    System.out.println(res);
                }
                scanner1.close();

//             
//                Filter filter2 = new RowFilter(CompareFilter.CompareOp.EQUAL,new RegexStringComparator("laoxia4\\d{2}"));
//                scan.setFilter(filter2);
//                ResultScanner scanner2 = table.getScanner(scan);
//                for (Result res : scanner2) {
//                     System.out.println(res);
//                }
//                scanner2.close();

                Filter filter3 = new RowFilter( CompareOp.EQUAL,new SubstringComparator("laoxia407"));
                scan.setFilter(filter3);
                ResultScanner scanner3 = table.getScanner(scan);
                for (Result res : scanner3) {
                      System.out.println(res);
                }
                scanner3.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
      @Test
      public void testTrasaction(){
          try{
              HTableInterface table = null;
              table = hTablePool.getTable("t_test".getBytes());
//              Put put1 =new Put("002".getBytes());
//              put1.add("cf1".getBytes(), "name".getBytes(), "王五".getBytes());
//              table.put(put1);
              Put newput =new Put("001".getBytes());
              newput.add("cf1".getBytes(), "like".getBytes(), "看书".getBytes());
              
              boolean f= table.checkAndPut("001".getBytes(), "cf1".getBytes(), "age".getBytes(), "24".getBytes(), newput);
              System.out.println(f);
              
          }catch (Exception e){
              e.printStackTrace();
          }
          
      }
}


 2.原始Api

package com.sxt.hbase;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Get;
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.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.PrefixFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class HBaseDemo {

    Configuration conf;
    HBaseAdmin admin;
    HTable htable;
    byte[] family = "cf".getBytes();
    
    // 1、删除 cell??
    // 2、表设计
    
    
    String TN = "phone";
    
    @Before
    public void begin() throws Exception {
        conf = new Configuration();
        
        // 分布式hbase  zk列表指定zk集群
        conf.set("hbase.zookeeper.quorum", "node05");
        
        admin = new HBaseAdmin(conf);//通过admin对象操作DDL语言
        htable = new HTable(conf, TN);//通过Htable对象操作表DML语言
    }
    
    @After
    public void end() throws Exception {
        if(admin != null) {
            admin.close();
        }
        if(htable != null) {
            htable.close();
        }
    }

    @Test
    public void createTbl() throws Exception {
        if(admin.tableExists(TN)) {
            admin.disableTable(TN);
            admin.deleteTable(TN);
        }
        
        HTableDescriptor desc = new HTableDescriptor(TableName.valueOf(TN));//表的描述

        HColumnDescriptor cf = new HColumnDescriptor("cf");
        cf.setInMemory(true);//设置读缓存
        cf.setMaxVersions(1);
        
        desc.addFamily(cf);//创建表的时候必须制定列族,相当于一个DDL语言描述。
        
        admin.createTable(desc);
    }
    
    @Test
    public void insertDB1() throws Exception {
        String rowkey = "123";
        
        Put put = new Put(rowkey.getBytes());
        put.add("cf".getBytes(), "name".getBytes(), "xiaoming".getBytes());
        put.add("cf".getBytes(), "sex".getBytes(), "man".getBytes());
        
        htable.put(put);
    }
    
    @Test
    public void getDB1() throws Exception {
        String rowkey = "123";
        Get get = new Get(rowkey.getBytes());
        get.addColumn("cf".getBytes(), "name".getBytes());
        
        Result rs = htable.get(get);
        Cell cell = rs.getColumnLatestCell("cf".getBytes(), "name".getBytes());//result返回的是一个Cell对象
        
        System.out.println(new String(CellUtil.cloneValue(cell)));//取出Cell对象中的值
    }
    
    /**
     * 通话详单 
     * 包含:手机号,对方手机号,日期,通话时长,主叫被叫类型...
     * 
     * Rowkey设计:手机号_(Long.Max-时间戳)
     * 
     * 1、查询某个月份 的  所有的通话详单  时间降序
     * 
     * 2、查询某个手机号   所有主叫类型   通话记录
     * @throws Exception
     */
    
    HTools t = new HTools();
    
    Random r = new Random();

    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
    
    /**
     * 生成测试数据
     * 
     * 十个用户 产生一百条通话记录 
     */
    @Test
    public void insertDB2() throws Exception {
        
        
        List<Put> puts = new ArrayList<Put>();
        
        for (int i = 0; i < 10; i++) {
            String pnum = t.getPhoneNum("186");
            
            for (int j = 0; j < 100; j++) {
                String dnum = t.getPhoneNum("177");
                String datestr = t.getDate("2018");
                String length = r.nextInt(99) + "";
                String type = r.nextInt(2) + "";
                
                String rowkey = pnum + "_" + (Long.MAX_VALUE-sdf.parse(datestr).getTime());//默认Hbase是按照row_key的字典升序排列,此处降序。
                
                Put put = new Put(rowkey.getBytes());

                put.add(family, "dnum".getBytes(), dnum.getBytes());
                put.add(family, "date".getBytes(), datestr.getBytes());
                put.add(family, "length".getBytes(), length.getBytes());
                put.add(family, "type".getBytes(), type.getBytes());
                
                puts.add(put);
            }
        }
        
        htable.put(puts);
    }
    
    /**
     * 查询某个手机号  某个月份所有的通话记录
     * 范围
     * @throws Exception
     */
    @Test
    public void scanDB1() throws Exception {
        Scan scan = new Scan();
        
        String pnum = "18692739289_";

        String startRowkey = pnum + (Long.MAX_VALUE-sdf.parse("20181001000000").getTime());
        String stopRowkey = pnum + (Long.MAX_VALUE-sdf.parse("20180901000000").getTime());
        
        scan.setStartRow(startRowkey.getBytes());
        scan.setStopRow(stopRowkey.getBytes());//scan操作设置起始和结束的rowkey
        
        ResultScanner rss = htable.getScanner(scan);//返回一个Result集合。
        for (Result rs : rss) {//遍历Result集合
            System.out.print(new String(CellUtil.cloneValue(rs.getColumnLatestCell(family, "dnum".getBytes()))));//得到一条条数据。
            System.out.print(" - " + new String(CellUtil.cloneValue(rs.getColumnLatestCell(family, "date".getBytes()))));
            System.out.print(" - " + new String(CellUtil.cloneValue(rs.getColumnLatestCell(family, "type".getBytes()))));
            System.out.println(" - " + new String(CellUtil.cloneValue(rs.getColumnLatestCell(family, "length".getBytes()))));
        }
    }
    
    /**
     * 查询某个手机号  所有的主叫type=1
     * 过滤器
     * @throws Exception 
     */
    @Test
    public void scanDB2() throws Exception {
        Scan scan = new Scan();
        
        FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ALL);//定义多个过滤器,必须全部筛选
        
        PrefixFilter filter1 = new PrefixFilter("18692739289".getBytes());//前缀过滤器,先返回所有以这个判定条件的rowkey
        list.addFilter(filter1);
        
        SingleColumnValueFilter filter2 = new SingleColumnValueFilter(family, //列值过滤器,因为是两个查询条件,所以需要两个过滤器
                "type".getBytes(), CompareOp.EQUAL, "1".getBytes()); //判断所有type等于1的值
        
        list.addFilter(filter2);//加第二个过滤器
        
        scan.setFilter(list);
        
        ResultScanner rss = htable.getScanner(scan);
        for (Result rs : rss) {
            System.out.print(new String(CellUtil.cloneValue(rs.getColumnLatestCell(family, "dnum".getBytes()))));
            System.out.print(" - " + new String(CellUtil.cloneValue(rs.getColumnLatestCell(family, "date".getBytes()))));
            System.out.print(" - " + new String(CellUtil.cloneValue(rs.getColumnLatestCell(family, "type".getBytes()))));
            System.out.println(" - " + new String(CellUtil.cloneValue(rs.getColumnLatestCell(family, "length".getBytes()))));
        }
        
    }
    
}


 解析:

1.

String rowkey = pnum + "_" + (Long.MAX_VALUE-sdf.parse(datestr).getTime());//默认Hbase是按照row_key的字典升序排列,此处降序。时间戳越来越大,则此数越来越小,达到按照时间降序的结果。

2.过滤器介绍

 

FilterList代表一个过滤器列表
        FilterList.Operator.MUST_PASS_ALL --> 取交集 相当一and操作
        FilterList.Operator.MUST_PASS_ONE --> 取并集 相当于or 操作
        FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ONE);
        2、SingleColumnValueFilter 列值过滤器
        ColumnPrefixFilter用于指定列名前缀值相等
        MultipleColumnPrefixFilter和ColumnPrefixFilter行为差不多,但可以指定多个前缀。
        QualifierFilter是基于列名的过滤器。
        2、RowFilter 行过滤器
        RegexStringComparator是支持正则表达式的比较器。
        SubstringComparator用于检测一个子串是否存在于值中,大小写不敏感。

 

【Hbase】hbase的java api操作(3) hbase的java api操作,使用java api创建hbase的表,使用java api删除表,往创建的表中插入数据,查看一条数据,删除一条数据,导入数据,查询2020年6月份所有用户的用水量,Export Job导出数据。 阅读详情

相关推荐

电磁仿真软件CST2020 下载链接及安装破·解教程笔记

众所周知,配环境是安装软件最头疼的事情。CST2020我调了一上午,网上现有的安装教程良莠不齐,很难有一篇文章能够全流程的讲述安装过程以及遇到的问题。正好今天我要给另一台电脑装软件,借此机会把安装过程记录下来,以供将来使用和他人借鉴。 首先提供下载地址: 百度网盘 链接:https://pan.baidu.com/s/1cDJZelufj-nliUfekMNpEA 提取码:8ihx 附: 根据二○○二年一月一日《计算机软件保护条例》规定:为了学习和研究软件内含的设计思想和原理,通过安装、显示、传输或者存储软

weixin_42845306的博客 3万+

java hbase 查询优化_HBase性能优化 Java Api

1.使用“连接池”如果每次和Hbase交互时都去新建连接的话,显然是低效率的,HBase也提供类连接池相关的API。1.1.HTablePool早期的API中使用它,但很不幸,现在它已经过时了。在次不再描述。1.2.HConnection取代HTablePool的就是现在的HConnection,可以通过它拿到几乎所有关于HBase的相关操作对象。private static HConnec...

weixin_35107023的博客 773

【AI知识点】启发式算法(Heuristic Algorithms)

启发式算法(Heuristic Algorithms) 是一种基于经验、直觉和局部优化的求解问题的算法,尤其适用于解决计算复杂度高、规模庞大的问题。它们通过简化问题、局部搜索和快速近似,提供了一种在短时间内获得“足够好”解的途径。虽然启发式算法无法保证全局最优解,但它们在实际应用中广泛使用,特别是在优化问题、任务调度和机器学习等领域。

AI完全体 3034

Hbase之一月速成:Hbase的JavaAPI操作

HBase+JavaAPI

weixin_46490924的博客 4486

COLMAP在Ubuntu下的编译陷阱与实战避坑指南——从环境配置到三维重建全流程

本文详细介绍了在Ubuntu系统下编译和配置COLMAP三维重建工具的全流程,包括环境准备、依赖库安装、CUDA加速配置以及常见编译问题的解决方案。通过实战案例演示了从图像特征提取到稠密重建的完整步骤,并提供了性能优化和问题排查的实用技巧,帮助用户高效完成三维重建任务。

weixin_29003437的博客 1049

Innovus Function ECO实战:5步搞定数字后端设计中的网表修正(含Calibre LVS验证技巧)

本文提供了一份完整的Innovus Function ECO实战指南,详细解析了数字后端设计中网表修正的五步流程。从理解Function ECO概念、准备关键文件,到在Innovus中执行逻辑比对、自动布线及GUI检查,并重点攻克了ECO后Calibre LVS验证的难点与调试技巧,帮助工程师高效、精准地完成流片前的设计微调。

day7的博客 952

java hbase 查询优化_JavaApi操作Hbase慢的问题

本帖最后由 北冥有鱼 于 2016-8-1 23:28 编辑我用java api操作hbase,测试的时候,3台机器,一台master,二台regionServer,自己搭的的zookeeper,建个表都是3秒多,,,,为什么这么慢呢.... 在很少的数据里面通过rowkey查询数据,也要好几秒..我用的1.2.1版本,论坛上的关于hbase优化的帖子我也看了,但是感觉我这问题不是优化的问题......

weixin_32150027的博客 1251

从CCD数据上报看wxHOOK的封号风险与规避

本文深入分析了微信CCD数据上报机制对wxHOOK的检测逻辑与封号风险,揭示了调试器路径暴露、非白名单DLL加载和内存校验失败等关键风险点。通过实战案例和规避方案,帮助开发者理解如何安全使用wxHOOK技术,避免封号风险,包括内存镜像欺骗、内核级隐蔽和硬件辅助方案等高级技巧。

weixin_27875131的博客 636

hbase java api 查询_java api 查询hbase

考虑到Java代码一般就是查询hbase存储的hadoop运算的结果数据,下面记录下查询的简单范例代码package com.lvmama.crm.web.controller.csVipManager;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.hbase.HBaseConfiguration;impo...

weixin_35968240的博客 326

wxComboBox类的使用方法及示例代码

其中,parent表示该控件的父窗口,ID_COMBOBOX是该控件的ID,用于在事件处理函数中区分不同的控件,"默认选项"是下拉列表框的默认选项,options是wxArrayString类型的数组,用于存储下拉列表框中的选项,style可以指定wxComboBox的样式。wxComboBox是wxWidgets中的一个常用控件,它可以被用来显示一组在下拉列表框中的选项,并允许用户从中选择一个选项。上述就是wxComboBox类的基本使用方法,使用这个控件可以方便地实现下拉列表框的功能。

学习使你进步。 714

AUTOSAR CP R18-10 架构总览与导航

AUTOSAR CP R18-10 架构总览 本文档系统整理了AUTOSAR CP R18-10版本的199篇技术规范,涵盖7大架构层级: 应用层(15篇):包含车身舒适、底盘控制、HMI、安全系统、动力系统等AI应用 RTE(1篇):虚拟功能总线规范 服务层(159篇):细分为系统服务(OS/ECU管理/加密)、存储服务、通信服务(CAN/LIN/Ethernet) ECU抽象层(20篇):I/O与通信硬件抽象 MCAL(41篇):微控制器驱动层 复杂驱动(14篇):CDD设计与SPAL支撑 规范模板(2

一名留德华的,康德的信徒的,专注于汽车电子领域的博客 724

HBase Java API操作

在IDEA上创建一个maven项目,并导入相关的依赖 <repositories> <repository> <id>aliyun</id> <url>http://maven.aliyun.com/nexus/content/groups/public/</url> <releases><enabled>true</enable

m0_58535137的博客 442

【Python音频处理】syncstart 计算媒体文件同步时间偏移

syncstart是一个强大的工具,它简化了多媒体文件的音视频同步过程,特别适用于多设备录制的媒体内容。在使用命令行工具时,可以根据实际需求灵活调整参数,如归一化、降噪、低通滤波等,以提高同步的精度和效率。通过本文介绍的基本操作和应用示例,可以快速掌握syncstart的使用方法,并将其应用到日常的音视频处理工作中。

Mr数据杨 820

(简单易懂)hbase——JavaApi

批量导入本机数据student.txt。

weixin_58184269的博客 3048

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

HBase的Java API操作

HBase的Java API操作代码,实现增删改查,过滤功能

qq_40078490的博客 2764

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

Hbase 操作命令

Hbase的操作命令,包括基础命令,数据读取,和API操作

m0_72168501的博客 1万+

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Hbase API以及java如何操作Hbase的说明

1.文章目的 本文主要包括两个方面的内容,一是Hbase Java API简介;二是一个完整的Java项目访问Hbase的步骤及示例代码。 本文档假设读者已在VMware上安装centOS虚拟机,并且已成功安装配置好Hadoop伪集群和Hbase数据库 2.Hbase的javaAPI简介 2.1几个相关类与HBase数据模型之间的对应关系 3.重点类介绍 3.1.HBaseConfigurati...

zhangbinch的博客 1292

eclipse 实现 HBase java API

HBase Java API 核心类介绍、创建表

博樽 3041

头歌 HBase(相关的五个实验)

头歌 HBase(相关的五个实验)

weixin_61657766的博客 3万+

HBase JAVA API

HBase JAVA API实验过程

qq_45973433的博客 2万+

大数据从入门到实战 - HBase 开发:使用Java操作HBase

大数据从入门到实战 - HBase 开发:使用Java操作HBase 一、关于此次实践 1、实战简介 2、全部任务 二、实践详解 1、第1关:创建表 2、第2关:添加数据 3、第3关:获取数据 4、第4关:删除表 叮嘟!这里是小啊呜的学习课程资料整理。好记性不如烂笔头,今天也是努力进步的一天。一起加油进阶吧!

小啊呜的博客 1万+

java api操作hbase_如何使用Java API操作Hbase

先导入hbase的相关jar包。e68a84e8a2ad3231313335323631343130323136353331333337383339再根据api进行操作。packagecom.util;importjava.io.IOException;importjava.util.ArrayList;importjava.util.List;importorg.apache.hado...

weixin_34270668的博客 559
上一篇: Mysql篇--Linux中安装Mysql
下一篇: Nginx篇--Nginx源码搭建
L先生AI课堂
L先生AI课堂 领域专家: 大数据技术领域 领域专家: 大数据技术领域
博客等级 码龄9年 678粉丝 216原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

L先生AI课堂

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明:

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

余额充值