凡是过往，皆为序章

0%

HBase_03

发表于 分类于 阅读次数： Valine：
本文字数： 90 阅读时长 ≈ 1 分钟

总结在本机Windows上通过JAVA 的 API 操作 HBase。

pom.xml 的配置信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>1.3.1</version>
</dependency>

<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-common</artifactId>
    <version>1.3.1</version>
</dependency>
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-protocol</artifactId>
    <version>1.3.1</version>
</dependency>

本篇代码进行了一定程度的封装，在本类的main方法中实现具体函数功能。

DDL的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package com.thorine.test;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;

import java.io.IOException;

/*
* DDL:
*   1、判断表是否存在
*   2、创建表
*   3、创建namespace
*   4、删除表
* DML：
*   5、插入数据
*   6、查询数据（get）
*   7、查询（scan）
*   8、删除数据
* */
public class TestDDL {
    /*
    * Connection代表客户端和集群的一个连接,这个连接包含对master的连接，和zk的连接
    * Connection的创建是重量级的，因此建议一个应用只创建一个Connection对象.
    * Connection是线程安全的，可以在多个线程中共享同一个Connection实例.
    *
    * 从Connection中获取Table和Admin对象的实例！Table和Admin对象的创建是轻量级，且不是线程安全的！
    * 因此不建议池化或缓存Table和Admin对象的实例，每个线程有自己的Table和Admin对象的实例！
    * */

    private static Connection connection = null;
    private static Admin admin = null;

    static {
        try {
            Configuration configuration = HBaseConfiguration.create();
            configuration.set("hbase.zookeeper.quorum", "bigdata1:2181,bigdata2:2181,bigdata3:2181");
            // 创建连接对象
            connection = ConnectionFactory.createConnection(configuration);
            // 创建管理员对象
            admin = connection.getAdmin();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 关闭资源
    public static void close(){
        if (admin != null) {
            try {
                admin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 1、判断表是否存在
    public static boolean isTableExist(String tableName) throws IOException {
        return admin.tableExists(TableName.valueOf(tableName));
    }


    //2、创建表
    // 第一个参数表明，第二个为可变参数，列族信息
    public static void createTable(String tableName, String... cfs) throws IOException {
        // 判断是否存在列族信息
        if (cfs.length <= 0) {
            System.out.println("请设置列族信息");
            return;
        }
        // 判断表是否存在
        if (isTableExist(tableName)) {
            System.out.println(tableName + " 表 已存在。");
            return;
        }

        // 3、创建表
        // 创建表描述器
        HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));

        // 循环添加列族信息
        for (String cf : cfs) {
            // 创建列族描述器
            HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(cf);
         // hColumnDescriptor.setMaxVersions(5); // 版本数

            // 添加具体列族信息
            hTableDescriptor.addFamily(hColumnDescriptor);
        }
        // 创建表
        admin.createTable(hTableDescriptor);
    }

    //4、删除表
    public static void dropTable(String tableName) throws IOException {
        if (!isTableExist(tableName)) {
            System.out.println(tableName + " 表不存在，无法删除！");
            return;
        }
        // 使表下线
        admin.disableTable(TableName.valueOf(tableName));
        // 删除表
        admin.deleteTable(TableName.valueOf(tableName));
    }

    // 创建命名空间
    public static void createNamespace(String nsName) {
        // 创建命名空间描述器
        NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create(nsName).build();

        // 创建命令空间
        try {
            admin.createNamespace(namespaceDescriptor);
        } catch (NamespaceExistException e) {
            System.out.println(nsName + " 命令空间已存在！");
        }
        catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("命令空间已存在，但我仍可以走到这！！");

    }


    public static void main(String[] args) throws IOException {
        System.out.println(isTableExist("stu1"));
        // 这个表名表示在命名空间0408下创建表stu1
        createTable("0408:stu1","info1","info2");

        dropTable("stu1");

        createNamespace("0408");

        System.out.println(isTableExist("stu1"));

        close(); // 关闭资源
    }
}

DML的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
package com.thorine.test;

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 java.io.IOException;

/*
 * DDL:
 *   1、判断表是否存在
 *   2、创建表
 *   3、创建namespace
 *   4、删除表
 * DML：
 *   5、插入数据
 *   6、查询数据（get）
 *   7、查询（scan）
 *   8、删除数据
 * */
public class TestDML {

    private static Connection connection = null;
    private static Admin admin = null;

    static {
        try {
            Configuration configuration = HBaseConfiguration.create();
            configuration.set("hbase.zookeeper.quorum", "bigdata1:2181,bigdata2:2181,bigdata3:2181");
            // 创建连接对象
            connection = ConnectionFactory.createConnection(configuration);
            // 创建管理员对象
            admin = connection.getAdmin();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 关闭资源
    public static void close(){
        if (admin != null) {
            try {
                admin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 向表中插入数据
    // 参数：表名，rowKey，列族，列名，value
   public static void putData(String tableName, String rowKey, String cf, String cn, String value) throws IOException {
        // 获取表对象
       Table table = connection.getTable(TableName.valueOf(tableName));

       // 创建put对象
       Put put = new Put(Bytes.toBytes(rowKey));// Bytes 为 hbase.utils 下的工具包，将目标类型转为字节数组

       // 给put对象赋值
       put.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cn),Bytes.toBytes(value));

       // 若想添加多个列，多调用下面方法即可
       // put.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cn),Bytes.toBytes(value));
       // put.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cn),Bytes.toBytes(value));

       // 插入数据
       // 若想添加多个RowKey，只需创建多个Put对象，放到一个集合里，再用下面的put方法，插入一个集合对象。
       table.put(put);
       // 关闭表连接
       table.close();
   }

   // 获取数据 get
    public static void getData(String tableName, String rowKey, String cf, String cn) throws IOException {
        // 获取表对象
        Table table = connection.getTable(TableName.valueOf(tableName));

        // 创建get对象
        Get get = new Get(Bytes.toBytes(rowKey));

        // 指定获取的列族
        // get.addFamily(Bytes.toBytes(cf));
        // 指定获取的列族 和 列
        get.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cn));

        // 设置获取数据的版本数
        get.setMaxVersions(5);

        // 获取数据
        Result result = table.get(get);

        // 解析result
        for (Cell cell : result.rawCells()) {
            System.out.print("ROW:" + Bytes.toString(CellUtil.cloneRow(cell)));
            System.out.print(", CN:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
            System.out.print(", VALUE:" + Bytes.toString(CellUtil.cloneValue(cell)));
            System.out.println(", CF:" + Bytes.toString(CellUtil.cloneFamily(cell)));
        }

        // 关闭表连接
        table.close();
    }

    // 获取数据 scan
    public static void scanTable(String tableName) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableName));

        // 构建Scan对象
        // Scan scan = new Scan();
        // 指定RowKey范围从 10010 到 1003 ，左闭右开
        Scan scan = new Scan(Bytes.toBytes("10010"),Bytes.toBytes("1003"));
        // 扫描表
        ResultScanner resultScanner = table.getScanner(scan);
        //解析
        for (Result result : resultScanner) {
            // 打印
            for (Cell cell : result.rawCells()) {
                System.out.print("ROW:" + Bytes.toString(CellUtil.cloneRow(cell)));
                System.out.print(", CN:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
                System.out.print(", VALUE:" + Bytes.toString(CellUtil.cloneValue(cell)));
                System.out.println(", CF:" + Bytes.toString(CellUtil.cloneFamily(cell)));

            }
        }
        table.close();
    }

    public static void deleteData(String tableName,String rowKey, String cf, String cn) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableName));
        // 构造删除对象
        Delete delete = new Delete(Bytes.toBytes(rowKey));

        // 设置删除的列
        // delete.addColumn();  // 删除最新的版本 ，十分诡异，慎用

        // 给指定的列删除所有的版本，若加上第三个参数时间戳，则表示删除指定时间戳以前的数据
        delete.addColumns(Bytes.toBytes(cf),Bytes.toBytes(cn));

        // 删除指定的列族
        delete.addFamily(Bytes.toBytes(cf));

        // 执行删除操作
        table.delete(delete);
        table.close();
    }


    public static void main(String[] args) throws IOException {
        // putData("stu","1004","info1","name","dongao");
//        getData("student","1001","info","name");
//        scanTable("stu");

        deleteData("stu","1002","","");
        close();
    }
}
~感谢你请我吃糖果~
-------------本文结束，感谢您的阅读，欢迎评论留言！-------------