HBase代码合集

依赖如下：

 <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-common</artifactId>
            <version>1.2.1</version>
        </dependency>
    </dependencies>

java代码连接HBase集群，并进行增删改查模板代码：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Before;
import org.junit.Test;

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

public class HbaseDemo01 {
    private Configuration conf = null;
    private Connection conn = null;
    @Before
    public void init() throws IOException {
        conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        //获取连接
        conn = ConnectionFactory.createConnection(conf);
    }
    @Test
    /**
     * 创建表
     */
    public void createTable() throws IOException {
        //获取一个表的管理器
        Admin admin = conn.getAdmin();
        //创建表描述器
        HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf("t_user_java".getBytes()));
        //创建一个列族描述器
        HColumnDescriptor hcd1 = new HColumnDescriptor("base_info");
        HColumnDescriptor hcd2 = new HColumnDescriptor("extra_info");
        //设置参数（可选）
        hcd1.setVersions(1,3);
        //将列族描述器添加到表描述器
        tableDescriptor.addFamily(hcd1).addFamily(hcd2);
        //利用表的管理器创建表
        admin.createTable(tableDescriptor);
        //释放资源
        admin.close();
        conn.close();
    }
    @Test
    /**
     * 修改表
     */
    public void modifyTable() throws IOException {
        //获取一个表的管理器
        Admin admin = conn.getAdmin();
        //获取表的描述器
        HTableDescriptor tableDescriptor = admin.getTableDescriptor(TableName.valueOf("t_user_java"));
        //修改表格描述器
        HColumnDescriptor hcd1 = tableDescriptor.getFamily("extra_info".getBytes());
        hcd1.setVersions(3,5);
        HColumnDescriptor hcd3 = new HColumnDescriptor("other_info");
        tableDescriptor.addFamily(hcd3);
        //修改表
        admin.modifyTable(TableName.valueOf("t_user_java"),tableDescriptor);
        //释放资源
        admin.close();
        conn.close();
    }
    @Test
    /**
     * 添加数据
     */
    public void putData() throws IOException {
        //构建table对象
        Table table = conn.getTable(TableName.valueOf("t_user_java"));
        //创建集合，存储put对象，当然也可以只添加一条数据
        ArrayList<Put> puts = new ArrayList<Put>();
        //创建多个put对象，添加数据
        Put put01 = new Put(Bytes.toBytes("user001"));
        put01.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("username"),Bytes.toBytes("yyqx"));

        Put put02 = new Put(Bytes.toBytes("user001"));
        put02.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("age"),Bytes.toBytes("18"));

        Put put03 = new Put("user002".getBytes());
        put03.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("lisi"));
        put03.addColumn(Bytes.toBytes("extra_info"), Bytes.toBytes("married"), Bytes.toBytes("false"));

        Put put04 = new Put("zhang_sh_01".getBytes());
        put04.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("zhang01"));
        put04.addColumn(Bytes.toBytes("extra_info"), Bytes.toBytes("married"), Bytes.toBytes("false"));

        Put put05 = new Put("zhang_sh_02".getBytes());
        put05.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("zhang02"));
        put05.addColumn(Bytes.toBytes("extra_info"), Bytes.toBytes("married"), Bytes.toBytes("false"));

        Put put06 = new Put("liu_sh_01".getBytes());
        put06.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("liu01"));
        put06.addColumn(Bytes.toBytes("extra_info"), Bytes.toBytes("married"), Bytes.toBytes("false"));

        Put put07 = new Put("zhang_bj_01".getBytes());
        put07.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("zhang03"));
        put07.addColumn(Bytes.toBytes("extra_info"), Bytes.toBytes("married"), Bytes.toBytes("false"));

        Put put08 = new Put("zhang_bj_01".getBytes());
        put08.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("zhang04"));
        put08.addColumn(Bytes.toBytes("extra_info"), Bytes.toBytes("married"), Bytes.toBytes("false"));
        //添加进集合
        puts.add(put01);
        puts.add(put02);
        puts.add(put03);
        puts.add(put04);
        puts.add(put05);
        puts.add(put06);
        puts.add(put07);
        puts.add(put08);
        //提交
        table.put(puts);
        //释放资源
        table.close();
        conn.close();
    }
    @Test
    /**
     * 读取数据
     */
    public void getData() throws IOException {
        //获取table对象
        Table table = conn.getTable(TableName.valueOf("t_user_java"));
        //创建一个get对象，用于获取数据，传入rowkey
        Get get = new Get("user001".getBytes());
        //处理结果
        Result result = table.get(get);
        List<Cell> cells = result.listCells();
        for (Cell cell : cells) {
            //获取行键
            byte[] rowArray = cell.getRowArray();
            //获取列族
            byte[] familyArray = cell.getFamilyArray();
            //获取列名称
            byte[] qualifierArray = cell.getQualifierArray();
            //获取值
            byte[] valueArray = cell.getValueArray();
            //打印，注意，全部打印会有乱码，截取关键部分打印即可
            System.out.println(new String(rowArray,cell.getRowOffset(),cell.getRowLength()));
            System.out.println(new String(familyArray,cell.getFamilyOffset(),cell.getFamilyLength()));
            System.out.println(new String(qualifierArray,cell.getQualifierOffset(),cell.getQualifierLength()));
            System.out.println(new String(valueArray,cell.getValueOffset(),cell.getValueLength()));
            System.out.println("---------");
        }
        //释放资源
        table.close();
        conn.close();
    }
    @Test
    /**
     * 用scan扫描批量查询
     */
    public void getDatas() throws IOException {
        //获取table对象
        Table table = conn.getTable(TableName.valueOf("t_user_java"));
        //获取scan对象
        Scan scan = new Scan();
        //查询数据
        ResultScanner scanner = table.getScanner(scan);
        //获得、处理数据
        Iterator<Result> iterator = scanner.iterator();
        while(iterator.hasNext()){
            Result result = iterator.next();
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                //获取行键
                byte[] rowArray = cell.getRowArray();
                //获取列族
                byte[] familyArray = cell.getFamilyArray();
                //获取列名称
                byte[] qualifierArray = cell.getQualifierArray();
                //获取值
                byte[] valueArray = cell.getValueArray();
                //打印，注意，全部打印会有乱码，截取关键部分打印即可
                System.out.println(new String(rowArray,cell.getRowOffset(),cell.getRowLength()));
                System.out.println(new String(familyArray,cell.getFamilyOffset(),cell.getFamilyLength()));
                System.out.println(new String(qualifierArray,cell.getQualifierOffset(),cell.getQualifierLength()));
                System.out.println(new String(valueArray,cell.getValueOffset(),cell.getValueLength()));
                System.out.println("---------");
            }
        }
        table.close();
        conn.close();
    }
    @Test
    /**
     * 删除数据
     */
    public void delData() throws IOException {
        //获取table对象
        Table table = conn.getTable(TableName.valueOf("t_user_java"));
        //创建delete对象
        Delete delete = new Delete("user001".getBytes());
        //删除数据
        delete.addColumn("base_info".getBytes(),"age".getBytes());
        table.delete(delete);
        //释放资源
        table.close();
        conn.close();
    }
    @Test
    /**
     * 删除表
     */
    public void delTable() throws IOException {
        //获取admin
        Admin admin = conn.getAdmin();
        //删除表之前，需要将表进行disable操作
        admin.disableTable(TableName.valueOf("t_user_java"));
        //删除表，慎用
        admin.deleteTable(TableName.valueOf("t_user_java"));
        //释放资源
        admin.close();
        conn.close();
    }
}

java代码连接HBase集群，过滤器过滤操作代码：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.FilterList.Operator;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Test;

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

public class HbaseDemo02 {
    @Test
    public void test() throws IOException {
        //rowkey前缀过滤器
        PrefixFilter prefixFilter = new PrefixFilter(Bytes.toBytes("zhang"));
        //filterMethod(prefixFilter);

        //行过滤器
        RowFilter rowFilter1 = new RowFilter(CompareOp.LESS,new BinaryComparator(Bytes.toBytes("user002")));
        RowFilter rowFilter2 = new RowFilter(CompareOp.EQUAL,new SubstringComparator("02"));
        //filterMethod(rowFilter1);
        //filterMethod(rowFilter2);

        //针对特定列的value过滤
        RegexStringComparator comparator1 = new RegexStringComparator("^zhang");
        //SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter("base_info".getBytes(), "username".getBytes(), CompareOp.EQUAL, comparator1);
        SubstringComparator comparator2 = new SubstringComparator("yy");
        //SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter("base_info".getBytes(), "username".getBytes(), CompareOp.EQUAL, comparator2);
        //filterMethod(filter);

        //针对列族的过滤器
        FamilyFilter filter1 = new FamilyFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("base_info")));
        FamilyFilter filter2 = new FamilyFilter(CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes("extra")));
        //filterMethod(filter1);
        //filterMethod(filter2);

        //针对列名的过滤器
        QualifierFilter filter = new QualifierFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("age")));
        //filterMethod(filter);

        //多重过滤器
        FilterList filterList = new FilterList(Operator.MUST_PASS_ALL);
        filterList.addFilter(filter1);
        filterList.addFilter(filter);
        filterMethod(filterList);


    }

    /**
     * 用scan扫描的方式过滤
     * @param filter
     */
    public  void filterMethod(Filter filter) throws IOException {
        Configuration configuration = HBaseConfiguration.create();
        //一定记得连接集群
        configuration.set("hbase.zookeeper.quorum","node01:2181,node02:2181,node03:2181");
        Connection conn = ConnectionFactory.createConnection(configuration);
        Scan scan = new Scan();
        //设置过滤器
        scan.setFilter(filter);
        //获取数据
        Table table = conn.getTable(TableName.valueOf("t_user_java"));
        ResultScanner scanner = table.getScanner(scan);
        Iterator<Result> iterator = scanner.iterator();
        while(iterator.hasNext()){
            Result result = iterator.next();
            //两种处理方式都可以
            /*CellScanner cellScanner = result.cellScanner();
            while (cellScanner.advance()){
                Cell current = cellScanner.current();
                byte[] rowArray = current.getRowArray();
                byte[] familyArray = current.getFamilyArray();
                byte[] valueArray = current.getValueArray();
                byte[] qualifierArray = current.getQualifierArray();
                //打印结果
                System.out.println(new String(rowArray, current.getRowOffset(), current.getRowLength()));
                System.out.print(new String(familyArray, current.getFamilyOffset(), current.getFamilyLength()));
                System.out.print(":" + new String(qualifierArray, current.getQualifierOffset(), current.getQualifierLength()));
                System.out.println(" " + new String(valueArray, current.getValueOffset(), current.getValueLength()));
                System.out.println("---------");
            }*/
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                //获取行键
                byte[] rowArray = cell.getRowArray();
                //获取列族
                byte[] familyArray = cell.getFamilyArray();
                //获取列名称
                byte[] qualifierArray = cell.getQualifierArray();
                //获取值
                byte[] valueArray = cell.getValueArray();
                //打印，注意，全部打印会有乱码，截取关键部分打印即可
                System.out.println(new String(rowArray,cell.getRowOffset(),cell.getRowLength()));
                System.out.println(new String(familyArray,cell.getFamilyOffset(),cell.getFamilyLength()));
                System.out.println(new String(qualifierArray,cell.getQualifierOffset(),cell.getQualifierLength()));
                System.out.println(new String(valueArray,cell.getValueOffset(),cell.getValueLength()));
                System.out.println("---------");
            }
        }
        //table.close();
        //conn.close();
    }
}