用Java操纵HBase数据库（新建表，插入，删除，查找）

java代码如下：

package db.insert;

/*

 * 创建一个students表,并进行相关操作

 */

import java.io.IOException;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.List;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;

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.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.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.io.compress.Compression.Algorithm;

import org.apache.hadoop.hbase.util.Bytes;

public class HBaseDBDao implements Serializable{

    /**

     *

     */

    private static final long serialVersionUID = 1L;

    // 声明静态配置

    private static Configuration conf = null;

    private static HBaseAdmin hAdmin;

    private static HTable table;

    public HBaseDBDao(){

         conf = HBaseConfiguration.create();

         conf.set("hbase.zookeeper.quorum", "192.168.1.154");

         conf.set("hbase.zookeeper.property.clientPort", "2181");

         conf.set("hbase.master", "192.168.1.154:6000");

         try {

            //初始化数据库管理员

            hAdmin = new HBaseAdmin(conf);

        } 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();

        }

    }

    //初始化HTable，在插入数据，查询数据之前必须先初始化

    public void initHTable(String tableName) throws IOException{

        table = new HTable(conf, tableName);

    }

    //判断表是否存在

    public boolean isExist(String tableName) throws IOException {

        return hAdmin.tableExists(tableName);

    }

    // 创建数据库表

    public void createTable(String tableName, String[] columnFamilys)

            throws Exception {

        if (hAdmin.tableExists(tableName)) {

            System.out.println("表 "+tableName+" 已存在！");

            System.exit(0);

        } else {

            // 新建一个表的描述

            HTableDescriptor tableDesc = new HTableDescriptor(tableName);

            // 在描述里添加列族

            for (String columnFamily : columnFamilys) {// 新建一个列的描述

                HColumnDescriptor hcd = new HColumnDescriptor(columnFamily);

                // 在列描述中设置Compression压缩格式

                hcd.setCompressionType(Algorithm.LZO);

　　　　　　　　　 tableDesc.addFamily(hcd);

            }

            // 根据配置好的描述建表

            hAdmin.createTable(tableDesc);

            System.out.println("创建表 "+tableName+" 成功!");

        }

    }

    // 删除数据库表

    public void deleteTable(String tableName) throws Exception {

        if (hAdmin.tableExists(tableName)) {

            // 关闭一个表

            hAdmin.disableTable(tableName);

            hAdmin.deleteTable(tableName);

            System.out.println("删除表 "+tableName+" 成功！");

        } else {

            System.out.println("删除的表 "+tableName+" 不存在！");

            System.exit(0);

        }

    }

    // 批量添加数据

    public void addRowBatch(String tableName, String row,

            String columnFamily, String column, String value) throws Exception {

        //将自动提交关闭，如果不关闭，每写一条数据都会进行提交，是导入数据较慢的主要因素

        table.setAutoFlush(false, false);

        //设置缓存大小，当缓存大于设置值时，hbase会自动提交。此处可自己尝试大小，一般对大数据量，设置为5M即可，本文设置为3M。

        table.setWriteBufferSize(5*1024*1024);

        Put put = new Put(Bytes.toBytes(row));// 指定行

        // 参数分别:列族、列、值

        put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column),

                Bytes.toBytes(value));

        table.put(put);

    }

    //执行flushCommits()操作，防止最后一次数据丢失（尤其是在spark中一个分片结束时）

    public void flushCommits(String tableName) throws Exception {

         table.flushCommits();

    }

    //添加一条数据

    public void addRow(String tableName, String row,

            String columnFamily, String column, String value) throws Exception {

        Put put = new Put(Bytes.toBytes(row));// 指定行

        // 参数分别:列族、列、值

        put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column),

                Bytes.toBytes(value));

        table.put(put);

    }

    // 删除一条(行)数据

    public static void delRow(String tableName, String row) throws Exception {

        Delete del = new Delete(Bytes.toBytes(row));

        table.delete(del);

    }

    // 删除多条数据

    public void delMultiRows(String tableName, String[] rows)

            throws Exception {

        List<Delete> delList = new ArrayList<Delete>();

        for (String row : rows) {

            Delete del = new Delete(Bytes.toBytes(row));

            delList.add(del);

        }

        table.delete(delList);

    }

    // 获取一条数据

    public void getRow(String tableName, String row) throws Exception {

        Get get = new Get(Bytes.toBytes(row));

        Result result = table.get(get);

        // 输出结果,raw方法返回所有keyvalue数组

        for (KeyValue rowKV : result.raw()) {

            System.out.print("行名:" + new String(rowKV.getRow()) + " ");

            System.out.print("时间戳:" + rowKV.getTimestamp() + " ");

            System.out.print("列族名:" + new String(rowKV.getFamily()) + " ");

            System.out.print("列名:" + new String(rowKV.getQualifier()) + " ");

            System.out.println("值:" + new String(rowKV.getValue()));

        }

    }

    // 获取所有数据

    public void getAllRows(String tableName) throws Exception {

        Scan scan = new Scan();

        ResultScanner results = table.getScanner(scan);

        // 输出结果

        for (Result result : results) {

            for (KeyValue rowKV : result.raw()) {

                System.out.print("行名:" + new String(rowKV.getRow()) + " ");

                System.out.print("时间戳:" + rowKV.getTimestamp() + " ");

                System.out.print("列族名:" + new String(rowKV.getFamily()) + " ");

                System.out

                        .print("列名:" + new String(rowKV.getQualifier()) + " ");

                System.out.println("值:" + new String(rowKV.getValue()));

            }

        }

    }

    // 主函数

    public static void main(String[] args) {

        HBaseDBDao hb = new HBaseDBDao();

        try {

            String tableName = "student";

            hb.initHTable(tableName);

            // 第一步：创建数据库表：“student”

            String[] columnFamilys = { "info", "course" };

            if(!hb.isExist(tableName))

                hb.createTable(tableName, columnFamilys);

            // 第二步：向数据表的添加数据

            // 添加第一行数据

            if (hb.isExist(tableName)) {

                hb.addRow(tableName, "zpc", "info", "age", "20");

                hb.addRow(tableName, "zpc", "info", "sex", "boy");

                hb.addRow(tableName, "zpc", "course", "china", "97");

                hb.addRow(tableName, "zpc", "course", "math", "128");

                hb.addRow(tableName, "zpc", "course", "english", "85");

                // 添加第二行数据

                hb.addRow(tableName, "henjun", "info", "age", "19");

                hb.addRow(tableName, "henjun", "info", "sex", "boy");

                hb.addRow(tableName, "henjun", "course", "china","90");

                hb.addRow(tableName, "henjun", "course", "math","120");

                hb.addRow(tableName, "henjun", "course", "english","90");

                // 添加第三行数据

                hb.addRow(tableName, "niaopeng", "info", "age", "18");

                hb.addRow(tableName, "niaopeng", "info", "sex","girl");

                hb.addRow(tableName, "niaopeng", "course", "china","100");

                hb.addRow(tableName, "niaopeng", "course", "math","100");

                hb.addRow(tableName, "niaopeng", "course", "english","99");

                // 第三步：获取一条数据

                System.out.println("**************获取一条(zpc)数据*************");

                hb.getRow(tableName, "zpc");

                // 第四步：获取所有数据

                System.out.println("**************获取所有数据***************");

                hb.getAllRows(tableName);

                // 第五步：删除一条数据

                System.out.println("************删除一条(zpc)数据************");

                HBaseDBDao.delRow(tableName, "zpc");

                hb.getAllRows(tableName);

                // 第六步：删除多条数据

                System.out.println("**************删除多条数据***************");

                String rows[] = new String[] { "henjun","niaopeng" };

                hb.delMultiRows(tableName, rows);

                hb.getAllRows(tableName);

                // 第七步：删除数据库

                System.out.println("***************删除数据库表**************");

                hb.deleteTable(tableName);

                System.out.println("表"+tableName+"存在吗？"+hb.isExist(tableName));

            } else {

                System.out.println(tableName + "此数据库表不存在！");

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

另一种采用工厂的操作方式如下：

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Serializable;

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.HBaseConfiguration;

import org.apache.hadoop.hbase.HColumnDescriptor;

import org.apache.hadoop.hbase.HTableDescriptor;

import org.apache.hadoop.hbase.MasterNotRunningException;

import org.apache.hadoop.hbase.TableName;

import org.apache.hadoop.hbase.ZooKeeperConnectionException;

import org.apache.hadoop.hbase.client.Connection;

import org.apache.hadoop.hbase.client.ConnectionFactory;

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.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;

import org.apache.hadoop.hbase.filter.Filter;

import org.apache.hadoop.hbase.filter.PrefixFilter;

import org.apache.hadoop.hbase.filter.RegexStringComparator;

import org.apache.hadoop.hbase.filter.RowFilter;

import org.apache.hadoop.hbase.io.compress.Compression.Algorithm;

import org.apache.hadoop.hbase.util.Bytes;

public class HBaseDBDao implements Serializable {

    /**

     *

     */

    private static final long serialVersionUID = 3112265674603751415L;

    // 声明静态配置

    private static Configuration conf = null;

    private static HBaseAdmin hAdmin;

    //private static HTable table;

    private static Connection conn ;

    private static HTable table;

    public HBaseDBDao() {

        conf = HBaseConfiguration.create();

        conf.set("hbase.zookeeper.quorum", "192.168.1.154");

        conf.set("hbase.zookeeper.property.clientPort", "2181");

        conf.set("hbase.master", "192.168.1.154:60000");

        try {

            // 初始化数据库管理员

            //hAdmin = new HBaseAdmin(conf);

            conn = ConnectionFactory.createConnection(conf);

            hAdmin = (HBaseAdmin) conn.getAdmin();

        } 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();

        }

    }

    public void initHTable(String tableName) throws IOException {

        table = (HTable) conn.getTable(TableName.valueOf(tableName));

        //table = new HTable(conf, Bytes.toBytes(tableName));

    }

    // 关闭自动提交

    public void closeAutoFlush() {

        table.setAutoFlush(false, false);

    }

    //关闭表格

    public void closeTable() throws IOException{

        table.close();

        System.out.println("成功关闭表格！");

    }

    //关闭connection

    public void closeConnection() throws IOException{

        conn.close();

        System.out.println("成功关闭链接！");

    }    

    // 判断表是否存在

    public boolean isExist(String tableName) throws IOException {

        return hAdmin.tableExists(tableName);

    }

    // 创建数据库表

    public void createTable(String tableName, String[] columnFamilys)

            throws Exception {

        if (hAdmin.tableExists(tableName)) {

            System.out.println("表 " + tableName + " 已存在！");

            // System.exit(0);

        } else {

            // 新建一个表的描述

            HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tableName));

            // 在描述里添加列族

            for (String columnFamily : columnFamilys) {

                // 新建一个列的描述

                HColumnDescriptor hcd = new HColumnDescriptor(columnFamily);

                // 在列描述中设置Compression压缩格式

//                hcd.setCompressionType(Algorithm.LZO);

                tableDesc.addFamily(hcd);

            }

            // 根据配置好的描述建表

            hAdmin.createTable(tableDesc);

            System.out.println("创建表 " + tableName + " 成功!");

        }

    }

工厂方式的改进操作如下：

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Serializable;

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.HBaseConfiguration;

import org.apache.hadoop.hbase.HColumnDescriptor;

import org.apache.hadoop.hbase.HTableDescriptor;

import org.apache.hadoop.hbase.MasterNotRunningException;

import org.apache.hadoop.hbase.TableName;

import org.apache.hadoop.hbase.ZooKeeperConnectionException;

import org.apache.hadoop.hbase.client.Connection;

import org.apache.hadoop.hbase.client.ConnectionFactory;

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.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;

import org.apache.hadoop.hbase.filter.Filter;

import org.apache.hadoop.hbase.filter.PrefixFilter;

import org.apache.hadoop.hbase.filter.RegexStringComparator;

import org.apache.hadoop.hbase.filter.RowFilter;

import org.apache.hadoop.hbase.io.compress.Compression.Algorithm;

import org.apache.hadoop.hbase.util.Bytes;

public class HBaseDBDao implements Serializable {

    private static final long serialVersionUID = -3338957140027388957L;

    // 声明静态配置

    private static Configuration conf = null;

    private static HBaseAdmin hAdmin;

    //private static HTable table;

    private static Connection conn ;

//    private static HTable table;

    public HBaseDBDao() {

        conf = HBaseConfiguration.create();

        conf.set("hbase.zookeeper.quorum", "192.168.1.154");

        conf.set("hbase.zookeeper.property.clientPort", "2181");

        conf.set("hbase.master", "192.168.1.154:60000");

        try {

            // 初始化数据库管理员

            //hAdmin = new HBaseAdmin(conf);

            conn = ConnectionFactory.createConnection(conf);

            hAdmin = (HBaseAdmin) conn.getAdmin();

        } 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();

        }

    }

    public HTable initHTable(String tableName) throws IOException {

        HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));

        //table = new HTable(conf, Bytes.toBytes(tableName));

        return table;

    }

    // 关闭自动提交

    public void closeAutoFlush(HTable table) {

        table.setAutoFlush(false, false);

    }

    //关闭表格

    public void closeTable(HTable table) throws IOException{

        table.close();

        System.out.println("成功关闭表格！");

    }

    //关闭connection

    public void closeConnection() throws IOException{

        conn.close();

        System.out.println("成功关闭链接！");

    }    

    // 判断表是否存在

    public boolean isExist(String tableName) throws IOException {

        return hAdmin.tableExists(tableName);

    }

    // 创建数据库表

    public void createTable(String tableName, String[] columnFamilys)

            throws Exception {

        if (hAdmin.tableExists(tableName)) {

            System.out.println("表 " + tableName + " 已存在！");

            // System.exit(0);

        } else {

            // 新建一个表的描述

            HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tableName));

            // 在描述里添加列族

            for (String columnFamily : columnFamilys) {

                // 新建一个列的描述

                HColumnDescriptor hcd = new HColumnDescriptor(columnFamily);

                // 在列描述中设置Compression压缩格式

//                hcd.setCompressionType(Algorithm.GZ);

                tableDesc.addFamily(hcd);

            }

            // 根据配置好的描述建表

            hAdmin.createTable(tableDesc);

            System.out.println("创建表 " + tableName + " 成功!");

        }

    }

    // 删除数据库表

    public void deleteTable(String tableName) throws Exception {

        if (hAdmin.tableExists(tableName)) {

            // 关闭一个表

            hAdmin.disableTable(tableName);

            hAdmin.deleteTable(tableName);

            System.out.println("删除表 " + tableName + " 成功！");

        } else {

            System.out.println("删除的表 " + tableName + " 不存在！");

            System.exit(0);

        }

    }

    // 批量添加数据

    public void addRowBatch(HTable table, String row, String columnFamily,

            String column, String value) throws Exception {

        // 将自动提交关闭，如果不关闭，每写一条数据都会进行提交，是导入数据较慢的主要因素

        //table.setAutoFlush(false, false);

        // 设置缓存大小，当缓存大于设置值时，hbase会自动提交。此处可自己尝试大小，一般对大数据量，设置为5M即可，本文设置为3M。

        table.setWriteBufferSize(5 * 1024 * 1024);

        Put put = new Put(Bytes.toBytes(row));// 指定行

        // 参数分别:列族、列、值

        put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column),

                Bytes.toBytes(value));

        table.put(put);

    }

    // 执行flushCommits()操作，防止最后一次数据丢失（尤其是在spark中一个分片结束时）

    public void flushCommits(HTable table) throws Exception {

        table.flushCommits();

    }

    // 添加一条数据

    public void addRow(HTable table, String row, String columnFamily,

            String column, String value) throws Exception {

        Put put = new Put(Bytes.toBytes(row));// 指定行

        // 参数分别:列族、列、值

        put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column),

                Bytes.toBytes(value));

        table.put(put);

    }

    // 删除一条(行)数据

    public static void delRow(HTable table, String row) throws Exception {

        Delete del = new Delete(Bytes.toBytes(row));

        table.delete(del);

    }

    // 删除多条数据

    public void delMultiRows(HTable table, String[] rows) throws Exception {

        List<Delete> delList = new ArrayList<Delete>();

        for (String row : rows) {

            Delete del = new Delete(Bytes.toBytes(row));

            delList.add(del);

        }

        table.delete(delList);

    }

    // 获取一条数据的详细信息

    public void getRow(HTable table, String row) throws Exception {

        Get get = new Get(Bytes.toBytes(row));

        Result result = table.get(get);

        // 输出结果,raw方法返回所有keyvalue数组

        for (Cell cell : result.rawCells()) {

            System.out.print("行名:" + new String(CellUtil.cloneRow(cell)) + " ");

            System.out.print("时间戳:" + cell.getTimestamp() + " ");

            System.out.print("列族名:" + new String(CellUtil.cloneFamily(cell)) + " ");

            System.out.print("列名:" + new String(CellUtil.cloneQualifier(cell))+ " ");

            System.out.println("值:" + new String(CellUtil.cloneValue(cell)));

        }

    }

    //获取一条数据的值

    public void getRowValue(HTable table,String row) throws Exception{

        Get geter = new Get(Bytes.toBytes(row));

        Result result  = table.get(geter);

        for(Cell cell : result.rawCells()){

            System.out.print(new String(CellUtil.cloneQualifier(cell))+ " ");

            System.out.println(new String(CellUtil.cloneValue(cell)));

        }

    }

    // 获取所有数据的详细信息

    public void getAllRows(HTable table) throws Exception {

        Scan scan = new Scan();

        ResultScanner results = table.getScanner(scan);

        // 输出结果

        for (Result result : results) {

            for (Cell cell : result.rawCells()) {

                System.out.print("行名:" + new String(CellUtil.cloneRow(cell))+ " ");

                System.out.print("时间戳:" + cell.getTimestamp() + " ");

                System.out.print("列族名:"+ new String(CellUtil.cloneFamily(cell)) + " ");

                System.out.print("列名:" + new String(CellUtil.cloneQualifier(cell)) + " ");

                System.out.println("值:" + new String(CellUtil.cloneValue(cell)));

            }

        }

    }

    // 获取所有数据的值

    public void getAllRowsValue(HTable table) throws Exception {

        int rownum = 0;

        Scan scan = new Scan();

        ResultScanner results = table.getScanner(scan);

        File file = new File("/usr/local/myjar/txt-for-project/hbase.txt");

        FileWriter filewriter = new FileWriter(file);

        BufferedWriter bfw = new BufferedWriter(filewriter);

        // 输出结果

        for (Result result : results) {

            String str = new String(result.getRow())+" ";

            rownum++;

            System.out.print(new String(result.getRow())+" ");

            for (Cell cell : result.rawCells()) {

                str = str + cell.getTimestamp()+" ";

                System.out.print(new String(CellUtil.cloneQualifier(cell)) + " ");

                System.out.print(new String(CellUtil.cloneValue(cell))+" ");

            }

            bfw.write(str+"\n");

            System.out.println();

        }

        System.out.println("条目数量"+rownum);

        bfw.close();

    }

    // 获取所有数据的值 加上filter

    public void getAllRowsValueWithFilter(HTable table) throws Exception {

        int rownum = 0;

        //String prefix = "144860945905310140";

        //Scan scan = new Scan(prefix.getBytes());

        //scan.setFilter(new PrefixFilter(prefix.getBytes()));

        Filter myFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,new RegexStringComparator(".*1449453890982"));

        Scan scan = new Scan();

        scan.setFilter(myFilter);        

        ResultScanner results = table.getScanner(scan);

        File file = new File("/usr/local/myjar/txt-for-project/hbase.txt");

        FileWriter filewriter = new FileWriter(file);

        BufferedWriter bfw = new BufferedWriter(filewriter);

        // 输出结果

        for (Result result : results) {

            String str = new String(result.getRow()) + " ";

            rownum++;

            System.out.print(new String(result.getRow()) + " ");

            for (Cell cell : result.rawCells()) {

                str = str + cell.getTimestamp() + " ";

                System.out.print(new String(CellUtil.cloneQualifier(cell))

                        + " ");

                System.out.print(new String(CellUtil.cloneValue(cell)) + " ");

            }

            bfw.write(str + "\n");

            System.out.println();

        }

        System.out.println("条目数量" + rownum);

        bfw.close();

    }

    // 主函数

    public static void main(String[] args) {

        HBaseDBDao hb = new HBaseDBDao();

        try {

            String tableName = "student";

//            hb.deleteTable(tableName);

            // 第一步：创建数据库表：“student”

            String[] columnFamilys = { "info", "course" };

            if(!hb.isExist(tableName))

                hb.createTable(tableName, columnFamilys);

            HTable table = hb.initHTable(tableName);

            // 第二步：向数据表的添加数据

            // 添加第一行数据

            if (hb.isExist(tableName)) {

                hb.addRow(table, "zpc", "info", "age", "20");

                hb.addRow(table, "zpc", "info", "sex", "boy");

                hb.addRow(table, "zpc", "course", "china", "97");

                hb.addRow(table, "zpc", "course", "math", "128");

                hb.addRow(table, "zpc", "course", "english", "85");

                // 添加第二行数据

                hb.addRow(table, "henjun", "info", "age", "19");

                hb.addRow(table, "henjun", "info", "sex", "boy");

                hb.addRow(table, "henjun", "course", "china","90");

                hb.addRow(table, "henjun", "course", "math","120");

                hb.addRow(table, "henjun", "course", "english","90");

                // 添加第三行数据

                hb.addRow(table, "niaopeng", "info", "age", "18");

                hb.addRow(table, "niaopeng", "info", "sex","girl");

                hb.addRow(table, "niaopeng", "course", "china","100");

                hb.addRow(table, "niaopeng", "course", "math","100");

                hb.addRow(table, "niaopeng", "course", "english","99");

                // 第三步：获取一条数据

                System.out.println("**************获取一条(zpc)数据*************");

                hb.getRow(table, "zpc");

                // 第四步：获取所有数据

                System.out.println("**************获取所有数据***************");

                hb.getAllRows(table);

                // 第五步：删除一条数据

                System.out.println("************删除一条(zpc)数据************");

                HBaseDBDao.delRow(table, "zpc");

                hb.getAllRows(table);

                // 第六步：删除多条数据

                System.out.println("**************删除多条数据***************");

                String rows[] = new String[] { "henjun","niaopeng" };

                hb.delMultiRows(table, rows);

                hb.getAllRows(table);

                // 第七步：删除数据库

                System.out.println("***************删除数据库表**************");

                hb.deleteTable(tableName);

                System.out.println("表"+tableName+"存在吗？"+hb.isExist(tableName));

            } else {

                System.out.println(tableName + "此数据库表不存在！");

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

注：上面的工厂模式低版本HBase无法使用。

采用线程池的操作方式如下：

package com.defcons;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Serializable;

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.HBaseConfiguration;

import org.apache.hadoop.hbase.HColumnDescriptor;

import org.apache.hadoop.hbase.HTableDescriptor;

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.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.CompareFilter;

import org.apache.hadoop.hbase.filter.Filter;

import org.apache.hadoop.hbase.filter.PrefixFilter;

import org.apache.hadoop.hbase.filter.RegexStringComparator;

import org.apache.hadoop.hbase.filter.RowFilter;

import org.apache.hadoop.hbase.io.compress.Compression.Algorithm;

import org.apache.hadoop.hbase.util.Bytes;

public class HBaseDBDao implements Serializable {

    private static final long serialVersionUID = -3338957140027388957L;

    // 声明静态配置

    private static Configuration conf = null;

    private static HBaseAdmin hAdmin;

    //private static HTable table;

    //采用线程池

    private static HTablePool pool ;

//    private static HTable table;

    public HBaseDBDao() {

        conf = HBaseConfiguration.create();

        conf.set("hbase.zookeeper.quorum", "192.168.1.154");

        conf.set("hbase.zookeeper.property.clientPort", "2181");

        conf.set("hbase.master", "192.168.1.154:60000");

        try {

            // 初始化数据库管理员

            hAdmin = new HBaseAdmin(conf);

            pool = new HTablePool(conf, 5); //创建可容纳5个线程的线程池

        } 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();

        }

    }

    public HTableInterface initHTable(String tableName) throws IOException {

        HTableInterface table = pool.getTable(tableName); //从线程池中获取一个线程

        //table = new HTable(conf, Bytes.toBytes(tableName));

        return table;

    }

    // 关闭自动提交

    public void closeAutoFlush(HTableInterface table) {

        table.setAutoFlush(false, false);

    }

    //关闭表格

    public void closeTable(HTableInterface table) throws IOException{

        table.close();

        System.out.println("成功关闭表格！");

    }

    //关闭connection

    public void closeConnection() throws IOException{

        pool.close(); //关闭线程池

        System.out.println("成功关闭链接！");

    }    

    // 判断表是否存在

    public boolean isExist(String tableName) throws IOException {

        return hAdmin.tableExists(tableName);

    }

    // 创建数据库表

    public void createTable(String tableName, String[] columnFamilys)

            throws Exception {

        if (hAdmin.tableExists(tableName)) {

            System.out.println("表 " + tableName + " 已存在！");

            // System.exit(0);

        } else {

            // 新建一个表的描述

            HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tableName));

            // 在描述里添加列族

            for (String columnFamily : columnFamilys) {

                // 新建一个列的描述

                HColumnDescriptor hcd = new HColumnDescriptor(columnFamily);

                // 在列描述中设置Compression压缩格式

//                hcd.setCompressionType(Algorithm.GZ);

                tableDesc.addFamily(hcd);

            }

            // 根据配置好的描述建表

            hAdmin.createTable(tableDesc);

            System.out.println("创建表 " + tableName + " 成功!");

        }

    }

    // 删除数据库表

    public void deleteTable(String tableName) throws Exception {

        if (hAdmin.tableExists(tableName)) {

            // 关闭一个表

            hAdmin.disableTable(tableName);

            hAdmin.deleteTable(tableName);

            System.out.println("删除表 " + tableName + " 成功！");

        } else {

            System.out.println("删除的表 " + tableName + " 不存在！");

            System.exit(0);

        }

    }

    // 批量添加数据

    public void addRowBatch(HTableInterface table, String row, String columnFamily,

            String column, String value) throws Exception {

        // 将自动提交关闭，如果不关闭，每写一条数据都会进行提交，是导入数据较慢的主要因素

        //table.setAutoFlush(false, false);

        // 设置缓存大小，当缓存大于设置值时，hbase会自动提交。此处可自己尝试大小，一般对大数据量，设置为5M即可，本文设置为3M。

        table.setWriteBufferSize(5 * 1024 * 1024);

        Put put = new Put(Bytes.toBytes(row));// 指定行

        // 参数分别:列族、列、值

        put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column),

                Bytes.toBytes(value));

        table.put(put);

    }

    // 执行flushCommits()操作，防止最后一次数据丢失（尤其是在spark中一个分片结束时）

    public void flushCommits(HTableInterface table) throws Exception {

        table.flushCommits();

    }

    // 添加一条数据

    public void addRow(HTableInterface table, String row, String columnFamily,

            String column, String value) throws Exception {

        Put put = new Put(Bytes.toBytes(row));// 指定行

        // 参数分别:列族、列、值

        put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column),

                Bytes.toBytes(value));

        table.put(put);

    }

    // 删除一条(行)数据

    public static void delRow(HTableInterface table, String row) throws Exception {

        Delete del = new Delete(Bytes.toBytes(row));

        table.delete(del);

    }

    // 删除多条数据

    public void delMultiRows(HTableInterface table, String[] rows) throws Exception {

        List<Delete> delList = new ArrayList<Delete>();

        for (String row : rows) {

            Delete del = new Delete(Bytes.toBytes(row));

            delList.add(del);

        }

        table.delete(delList);

    }

    // 获取一条数据的详细信息

    public void getRow(HTableInterface table, String row) throws Exception {

        Get get = new Get(Bytes.toBytes(row));

        Result result = table.get(get);

        // 输出结果,raw方法返回所有keyvalue数组

        for (Cell cell : result.rawCells()) {

            System.out.print("行名:" + new String(CellUtil.cloneRow(cell)) + " ");

            System.out.print("时间戳:" + cell.getTimestamp() + " ");

            System.out.print("列族名:" + new String(CellUtil.cloneFamily(cell)) + " ");

            System.out.print("列名:" + new String(CellUtil.cloneQualifier(cell))+ " ");

            System.out.println("值:" + new String(CellUtil.cloneValue(cell)));

        }

    }

    //获取一条数据的值

    public void getRowValue(HTableInterface table,String row) throws Exception{

        Get geter = new Get(Bytes.toBytes(row));

        Result result  = table.get(geter);

        for(Cell cell : result.rawCells()){

            System.out.print(new String(CellUtil.cloneQualifier(cell))+ " ");

            System.out.println(new String(CellUtil.cloneValue(cell)));

        }

    }

    // 获取所有数据的详细信息

    public void getAllRows(HTableInterface table) throws Exception {

        Scan scan = new Scan();

        ResultScanner results = table.getScanner(scan);

        // 输出结果

        for (Result result : results) {

            for (Cell cell : result.rawCells()) {

                System.out.print("行名:" + new String(CellUtil.cloneRow(cell))+ " ");

                System.out.print("时间戳:" + cell.getTimestamp() + " ");

                System.out.print("列族名:"+ new String(CellUtil.cloneFamily(cell)) + " ");

                System.out.print("列名:" + new String(CellUtil.cloneQualifier(cell)) + " ");

                System.out.println("值:" + new String(CellUtil.cloneValue(cell)));

            }

        }

    }

    // 获取所有数据的值

    public void getAllRowsValue(HTableInterface table) throws Exception {

        int rownum = 0;

        Scan scan = new Scan();

        ResultScanner results = table.getScanner(scan);

        File file = new File("/usr/local/myjar/txt-for-project/hbase.txt");

        FileWriter filewriter = new FileWriter(file);

        BufferedWriter bfw = new BufferedWriter(filewriter);

        // 输出结果

        for (Result result : results) {

            String str = new String(result.getRow())+" ";

            rownum++;

            System.out.print(new String(result.getRow())+" ");

            for (Cell cell : result.rawCells()) {

                str = str + cell.getTimestamp()+" ";

                System.out.print(new String(CellUtil.cloneQualifier(cell)) + " ");

                System.out.print(new String(CellUtil.cloneValue(cell))+" ");

            }

            bfw.write(str+"\n");

            System.out.println();

        }

        System.out.println("条目数量"+rownum);

        bfw.close();

    }

    // 获取所有数据的值 加上filter

    public void getAllRowsValueWithFilter(HTableInterface table) throws Exception {

        int rownum = 0;

        //String prefix = "144860945905310140";

        //Scan scan = new Scan(prefix.getBytes());

        //scan.setFilter(new PrefixFilter(prefix.getBytes()));

        Filter myFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,new RegexStringComparator(".*1449453890982"));

        Scan scan = new Scan();

        scan.setFilter(myFilter);        

        ResultScanner results = table.getScanner(scan);

        File file = new File("/usr/local/myjar/txt-for-project/hbase.txt");

        FileWriter filewriter = new FileWriter(file);

        BufferedWriter bfw = new BufferedWriter(filewriter);

        // 输出结果

        for (Result result : results) {

            String str = new String(result.getRow()) + " ";

            rownum++;

            System.out.print(new String(result.getRow()) + " ");

            for (Cell cell : result.rawCells()) {

                str = str + cell.getTimestamp() + " ";

                System.out.print(new String(CellUtil.cloneQualifier(cell))

                        + " ");

                System.out.print(new String(CellUtil.cloneValue(cell)) + " ");

            }

            bfw.write(str + "\n");

            System.out.println();

        }

        System.out.println("条目数量" + rownum);

        bfw.close();

    }

}

所需jar包如下：

aaarticlea/png;base64,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" alt="" />