hbase創建資料庫_HBase是什麼呢都有哪些特點呢

① linux上搭建hbase

1.下載和安裝hbase資料庫
[root@tong1 ~]# wget http://mirrors.hust.e.cn/apache/hbase/stable/hbase-0.98.9-hadoop2-bin.tar.gz
[root@tong1 ~]# tar xvf hbase-0.98.9-hadoop2-bin.tar.gz
[root@tong1 ~]# mv hbase-0.98.9-hadoop2 /usr/local/
[root@tong1 local]# chown -R hadoop:hadoop hbase-0.98.9-hadoop2
[root@tong1 local]# ll hbase-0.98.9-hadoop2
total 352
drwxr-xr-x. 4 hadoop hadoop 4096 Dec 16 14:16 bin
-rw-r--r--. 1 hadoop hadoop 164928 Dec 16 14:20 CHANGES.txt
drwxr-xr-x. 2 hadoop hadoop 4096 Jan 8 12:48 conf
drwxr-xr-x. 4 hadoop hadoop 4096 Dec 16 14:16 dev-support
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:22 hbase-annotations
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-assembly
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:22 hbase-checkstyle
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-client
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:22 hbase-common
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-examples
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:25 hbase-hadoop1-compat
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-hadoop2-compat
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-hadoop-compat
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-it
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-prefix-tree
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-protocol
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-rest
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-server
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-shell
drwxr-xr-x. 2 hadoop hadoop 4096 Dec 16 14:23 hbase-testing-util
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 14:23 hbase-thrift
-rw-r--r--. 1 hadoop hadoop 11358 Dec 2 07:36 LICENSE.txt
drwxrwxr-x. 2 hadoop hadoop 4096 Jan 8 12:01 logs
-rw-r--r--. 1 hadoop hadoop 897 Dec 16 14:16 NOTICE.txt
-rw-r--r--. 1 hadoop hadoop 81667 Dec 16 14:16 pom.xml
-rw-r--r--. 1 hadoop hadoop 1377 Dec 16 14:16 README.txt
drwxr-xr-x. 3 hadoop hadoop 4096 Dec 16 06:37 src
[root@tong1 local]#

2.修改hbase配置文件
[root@tong1 local]# cd /usr/local/hbase-0.98.9-hadoop2/conf/
[root@tong1 conf]# vim hbase-site.xml
<configuration>
<property>
<name>hbase.rootdir</name>
<value>hdfs://tong1:9000/hbase</value> -與hadoop中的core-site.xml文件中一至
</property>
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
</configuration>
[root@tong1 conf]# vim hbase-env.sh
export JAVA_HOME=/usr/local/jdk1.8.0_25
[root@tong1 conf]#

3.啟動hbase服務
[root@tong1 conf]# su - hadoop
[hadoop@tong1 ~]$ start-hbase.sh
localhost: starting zookeeper, logging to /usr/local/hbase-0.98.9-hadoop2/bin/../logs/hbase-hadoop-zookeeper-tong1.out
starting master, logging to /usr/local/hbase-0.98.9-hadoop2/logs/hbase-hadoop-master-tong1.out
localhost: starting regionserver, logging to /usr/local/hbase-0.98.9-hadoop2/bin/../logs/hbase-hadoop-regionserver-tong1.out
[hadoop@tong1 ~]$ hbase shell
2015-01-08 15:01:36,052 INFO [main] Configuration.deprecation: hadoop.native.lib is deprecated. Instead, use io.native.lib.available
2015-01-08 15:01:36,082 INFO [main] Configuration.deprecation: hadoop.native.lib is deprecated. Instead, use io.native.lib.available
2015-01-08 15:01:36,109 INFO [main] Configuration.deprecation: hadoop.native.lib is deprecated. Instead, use io.native.lib.available
2015-01-08 15:01:36,135 INFO [main] Configuration.deprecation: hadoop.native.lib is deprecated. Instead, use io.native.lib.available
2015-01-08 15:01:36,147 INFO [main] Configuration.deprecation: hadoop.native.lib is deprecated. Instead, use io.native.lib.available
HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version 0.98.9-hadoop2, , Mon Dec 15 23:00:20 PST 2014

hbase(main):008:0* create 'tong1' ,'test'
0 row(s) in 0.9120 seconds
=> Hbase::Table - tong1
hbase(main):009:0> scan 'tong1'
ROW COLUMN+CELL
0 row(s) in 0.0390 seconds
hbase(main):010:0>

4.在瀏覽器查看狀態即可。

② hbase資料庫是關系型資料庫嗎

Hive 存儲格式和關系型資料庫之間進行導入導出

最近更新時間：2020-09-29 15:54:18

前往 GitHub 編輯

我的收藏

本頁目錄：

1. 開發准備
2. 將關系型資料庫導入到 Hive 中
3. 將 Hive 導入到關系型資料庫中
使用 HDFS 中的 Hive 數據
使用 Hcatalog 進行導入
4. 將 orc 格式的 Hive 表格導入到關系型資料庫中

本文介紹了使用騰訊雲 Sqoop 服務將數據在 Mysql 和 Hive 之間相互導入導出的方法。

1. 開發准備

確認已開通騰訊雲，並且創建了一個 EMR 集群。在創建 EMR 集群的時候需要在軟體配置界面選擇 Sqoop，Hive 組件。
Sqoop 等相關軟體安裝在路徑 EMR 雲伺服器的/usr/local/service/路徑下。

2. 將關系型資料庫導入到 Hive 中

本節將繼續使用上一節的用例。

進入 EMR 控制台，復制目標集群的實例 ID，即集群的名字。再進入關系型資料庫控制台，使用 Ctrl+F 進行搜索，找到集群對應的 MySQL 資料庫，查看該資料庫的內網地址 $mysqlIP。

登錄 EMR 集群中的任意機器，最好是登錄到 Master 節點。登錄 EMR 的方式請參考登錄 Linux 實例。這里我們可以選擇使用 WebShell 登錄。單擊對應雲伺服器右側的登錄，進入登錄界面，用戶名默認為 root，密碼為創建 EMR 時用戶自己輸入的密碼。輸入正確後，即可進入命令行界面。

在 EMR 命令行先使用以下指令切換到 Hadoop 用戶，並進入 Hive 文件夾：

[root@172 ~]# su hadoop[hadoop@172 ~]# cd /usr/local/service/hive

新建一個 Hive 資料庫：

[hadoop@172 hive]$ hive

hive> create database hive_from_sqoop;

Time taken: 0.167 seconds

使用 sqoop-import 命令把上一節中創建的 MySQL 資料庫導入到 Hive 中：

[hadoop@172 hive]# cd /usr/local/service/sqoop

[hadoop@172 sqoop]$ bin/sqoop-import --connect jdbc:mysql://$mysqlIP/test --username root -P --table sqoop_test_back --hive-database hive_from_sqoop --hive-import --hive-table hive_from_sqoop

$mysqlIP：騰訊雲關系型資料庫（CDB）的內網地址。
test：MySQL 資料庫名稱。
--table：要導出的 MySQL 表名。
--hive-database：Hive 資料庫名。
--hive-table：導入的 Hive 表名。

執行指令需要輸入您的 MySQL 密碼，默認為您創建 EMR 集群時設置的密碼。執行成功後，可以在 Hive 中查看導入的資料庫：

hive> select * from hive_from_sqoop;OK1 first 2018-07-03 16:07:46.0 spark2 second 2018-07-03 15:30:57.0 mr3 third 2018-07-03 15:31:07.0 yarn4 forth 2018-07-03 15:39:38.0 hbase5 fifth 2018-07-03 16:02:29.0 hive6 sixth 2018-07-03 16:09:58.0 sqoopTime taken: 1.245 seconds, Fetched: 6 row(s)

3. 將 Hive 導入到關系型資料庫中

Sqoop 支持將 Hive 表中的數據導入到關系型資料庫中。先在 Hive 中創建新表並導入數據。

登錄 EMR 集群中的任意機器，最好是登錄到 Master 節點。在 EMR 命令行先使用以下指令切換到 Hadoop 用戶，並進入 Hive 文件夾：

[root@172 ~]# su hadoop[hadoop@172 ~]# cd /usr/local/service/hive

新建一個 bash 腳本文件 gen_data.sh，在其中添加以下代碼：

#!/bin/bashMAXROW=1000000 #指定生成數據行數for((i = 0; i < $MAXROW; i++))doecho $RANDOM, "$RANDOM"done

並按如下方式執行：

[hadoop@172 hive]$ ./gen_data.sh > hive_test.data

這個腳本文件會生成1,000,000個隨機數對，並且保存到文件 hive_test.data 中。

使用如下指令把生成的測試數據先上傳到 HDFS 中：

[hadoop@172 hive]$ hdfs dfs -put ./hive_test.data /$hdfspath

其中 $hdfspath 為 HDFS 上的您存放文件的路徑。

連接 Hive 並創建測試表：

[hadoop@172 hive]$ bin/hivehive> create database hive_to_sqoop; #創建資料庫 hive_to_sqoopOK

Time taken: 0.176 secondshive> use hive_to_sqoop; #切換資料庫OK

Time taken: 0.176 secondshive> create table hive_test (a int, b string)hive> ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';#創建數據表 hive_test, 並指定列分割符為』,』

Time taken: 0.204 secondshive> load data inpath "/$hdfspath/hive_test.data" into table hive_test; #導入數據

$hdfspath 為 HDFS 上的您存放文件的路徑。

成功後可使用quit命令退出 Hive 數據倉庫。連接關系型資料庫並創建對應的表格：

[hadoop@172 hive]$ mysql -h $mysqlIP –p

Enter password:

其中 $mysqlIP 為該資料庫的內網地址，密碼為您創建集群時設置的密碼。

在 MySQL 中創建一個名為 test 的表格，MySQL 中的表欄位名字和 Hive 中的表欄位名字必須完全一致：

mysql> create table table_from_hive (a int,b varchar(255));

成功創建表格後即可退出 MySQL。

使用 Sqoop 把 Hive 數據倉庫中的數據導入到關系型資料庫中有兩種方法，可以直接使用 HDFS 存儲的 Hive 數據，也可以使用 Hcatalog 來進行數據的導入。

使用 HDFS 中的 Hive 數據

切換進入 Sqoop 文件夾，然後使用以下指令把 Hive 資料庫中的數據導出到關系型資料庫中：

[hadoop@172 hive]$ cd ../sqoop/bin

[hadoop@172 bin]$ ./sqoop-export --connect jdbc:mysql://$mysqlIP/test --username root -P

--table table_from_hive --export-dir /usr/hive/warehouse/hive_to_sqoop.db/hive_test

其中 $mysqlIP 為您的關系型資料庫的內網 IP 地址，test 為關系型資料庫中的資料庫名，--table 後跟的參數為您的關系型資料庫的表名，--export-dir 後跟的參數為 Hive 表中的數據在 HDFS 中存儲的位置。

使用 Hcatalog 進行導入

切換進入 Sqoop 文件夾，然後使用以下指令把 Hive 資料庫中的數據導出到關系型資料庫中：

[hadoop@172 hive]$ cd ../sqoop/bin

[hadoop@172 bin]$ ./sqoop-export --connect jdbc:mysql://$mysqlIP/test --username root -P

--table table_from_hive --hcatalog-database hive_to_sqoop --hcatalog-table hive_test

其中 $mysqlIP 為您的關系型資料庫的內網 IP 地址，test 為關系型資料庫中的資料庫名，--table 後跟的參數為您的關系型資料庫的表名，--hcatalog-database 後面跟的參數是要導出的 Hive 表所在的資料庫的名稱，--hcatalog-table 後面跟的參數是要 Hive 中要導出的表的名稱。

操作完成後可以進入關系型資料庫查看是否導入成功：

[hadoop@172 hive]$ mysql -h $mysqlIP –p #連接 MySQLEnter password:mysql> use test;

Database changed

mysql> select count(*) from table_from_hive; #現在表中有1000000條數據+----------+| count(*) |+----------+| 1000000 |+----------+1 row in set (0.03 sec)

mysql> select * from table_from_hive limit 10; #查看錶中前10條記錄+-------+----------+| a | b |

+-------+----------+

| 28523 | "3394" || 31065 | "24583" |

| 399 | "23629" || 18779 | "8377" |

| 25376 | "30798" || 20234 | "22048" |

| 30744 | "32753" || 21423 | "6117" |

| 26867 | "16787" || 18526 | "5856" |

+-------+----------+

10 rows in set (0.00 sec)

更多關於 sqoop-export 命令的參數可以通過如下命令查看：

[hadoop@172 bin]$ ./sqoop-export --help

4. 將 orc 格式的 Hive 表格導入到關系型資料庫中

③ HBase是什麼為什麼要使用HBase

HBase在產品中還包含了Jetty，在HBase啟動時採用嵌入式的方式來啟動Jetty，因此可以通過web界面對HBase進行管理和查看當前運行的一些狀態，非常輕巧。為什麼採用HBase？HBase 不同於一般的關系資料庫,它是一個適合於非結構化數據存儲的資料庫.所謂非結構化數據存儲就是說HBase是基於列的而不是基於行的模式，這樣方面讀寫你的大數據內容。 HBase是介於Map Entry(key & value)和DB Row之間的一種數據存儲方式。就點有點類似於現在流行的Memcache，但不僅僅是簡單的一個key對應一個 value，你很可能需要存儲多個屬性的數據結構，但沒有傳統資料庫表中那麼多的關聯關系，這就是所謂的鬆散數據。簡單來說，你在HBase中的表創建的可以看做是一張很大的表，而這個表的屬性可以根據需求去動態增加，在HBase中沒有表與表之間關聯查詢。你只需要告訴你的數據存儲到Hbase的那個column families 就可以了，不需要指定它的具體類型：char,varchar,int,tinyint,text等等。但是你需要注意HBase中不包含事務此類的功能。 Apache HBase 和Google Bigtable 有非常相似的地方，一個數據行擁有一個可選擇的鍵和任意數量的列。表是疏鬆的存儲的，因此用戶可以給行定義各種不同的列，對於這樣的功能在大項目中非常實用，可以簡化設計和升級的成本。

④ hbase創建表時出現connection closed錯誤

解決方法如下：
先關閉hbase和hadoop進程
查看hdfs-site.xml
把這兩個文件夾中的文件全部刪除（name文件夾同理）
重新執行hadoop格式化
HBase是一個分布式的、面向列的開源資料庫，該技術來源於 Fay Chang 所撰寫的Google論文「Bigtable：一個結構化數據的分布式存儲系統」。就像Bigtable利用了Google文件系統（File System）所提供的分布式數據存儲一樣，HBase在Hadoop之上提供了類似於Bigtable的能力。HBase是Apache的Hadoop項目的子項目。HBase不同於一般的關系資料庫，它是一個適合於非結構化數據存儲的資料庫。另一個不同的是HBase基於列的而不是基於行的模式。

⑤ 總結sql型資料庫和hbase資料庫的可視化界面有哪些並描述

可視化界面。總結sql型資料庫和hbase資料庫都是用於存儲和管理數據的關系資料庫類型。這兩種類型的資料庫都具有可視化界面，允許用戶與資料庫交互並執行創建表、插入數據和運行查詢等任務。

⑥ 如何將hbase.site.xml導入項目

方法1：最基本的數據導入方法。首先通過JDBC將原本關系型資料庫中的數據讀出到內存中，然後在使用HBase自帶的客戶端API將數據put到相應的表中。這種方法通用性強，只要寫好介面就可以用，但是效率並不高。
方法2：使用這種方法之前其實是需要先將數據導出到本地，以文本的形式保存，然後使用TableReudcer類編寫MapRece job。這種方法需要頻繁的I/O操作，所以效率不高，容易導致HBase節點的不穩定。
方法3：importtsv是HBase內置的數據導入工具，目的是將tsv格式的文件載入到HBase中，本質上它是通過調用MapReudce Job實現數據導入的。注意:使用該方法，需要提前將數據導出到本地，以tsv格式存儲。unbulk load模式的importtsv效果一般，適用於小型的數據。
方法4：bulk load是一個快速大量數據高效導入工具，相比於importtsv效率更高。
方法5：Sqoop是apache軟體基金會的一個項目，可以用來實現關系型資料庫和hdfs,hbase,hive之間的數據高效傳輸。只需要做一些簡單的配置，通過Sqoop命令行指令就可以方便的實現數據導入和導出。

下面具體介紹每種方法的做法：

JDBC & HBase Client API

此處以MySql為例。首先在MySql資料庫中創建database 『test』,然後創建一張表』Info』，這里可以使用可視化軟體（例如workbench），也可以直接在命令行輸入相應指令：

:~$mysql -u root -p #root用戶登錄mysql
#創建Info表
CREATE TABLE Info (`ID` INT NOT NULL,
`Name` VARCHAR(45) NOT NULL,
`Number` INT NOT NULL,
`Time` VARCHAR(45) NOT NULL,
PRIMARY KEY (`ID`));
1
2
3
4
5
6
7
1
2
3
4
5
6
7
然後使用load指令將准備好的數據導入到Info中。數據格式與Info各欄位的一致即可。

load data local infile '/home/lvyang/Desktop/test.csv' into table Info fields terminated by ','
1
1
到此數據已經准備好了。下面就可以進行數據導出導入過程了。
由於需要使用MySql的數據讀取介面，所以我們需要到官網下載相應的connector,並將其中包含的mysql-connector-java-版本號-bin.jar文件取出，添加到自己Project的依賴庫中。如果對maven比較熟的，就可以忽視這些配置過程，直接配置pom.xml文件即可完成項目依賴設置，方便快捷。
JDBC數據讀取：

public class JDBCUtils {
Connection conn=null;
ResultSet rs=null;
String databaseName=null;
String userName=null;
String password=null;
String url=null;
public JDBCUtils(String databaseName, String userName, String password, String url);
public void connect();
public ResultSet readData(String sql);
public void writeToConsole(ResultSet rs,String[] keys);
public boolean writeToLocal(ResultSet rs,String path);
public void close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
上面是JDBC工具類定義，可以根據自己的需求，自行添加或者刪除方法。部分方法的實現如下，僅做參考：

public void connect(){
try {
Class.forName("com.mysql.jdbc.Driver"); //注冊驅動
System.out.println("load mysql driver successfully!");
conn= (Connection) DriverManager.getConnection(url); //獲得connection對象，完成資料庫連接
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
public ResultSet readData(String sql){
try {
Statement stmt= (Statement) conn.createStatement(); //創建statement對象
rs=stmt.executeQuery(sql); //執行query命令，獲取ResultSet
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
public void close(){
if(rs!=null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
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
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
到此JDBC讀取數據部分已經完成，下面需要實現HBase數據導入功能：

public class HBaseUtils {
private static final Log LOG= LogFactory.getLog(HBaseUtils.class); //LOG用於輸出部分關鍵信息
//Here I choose construct func to init configuration instance
//and then use connectionFactory to create init conn instance
//at last,I use conn to get Hadmin instance
//next I will use Hadmin to operate hbase tables
private Configuration conf=null;
private Admin Hadmin=null;
private Connection conn=null;
public HBaseUtils(Configuration conf);
public void connect();
public boolean isExist(String tableName);
public boolean createTable(String tableName,String columnFamily);
public boolean writeOne(HashMap<String,String> data,String[] keys, String tableName,String columnFamily);
public boolean writeMore(List<HashMap<String,String>> list,String[] keys,String tableName,String columnFamily);
public boolean deleteTable(String tableName);
public void close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
部分方法的實現如下，僅做參考：

public void connect(){
try {
//create connection to hbase
conn= ConnectionFactory.createConnection(conf);
//get Hadmin which is the database manager
Hadmin=conn.getAdmin();
} catch (IOException e) {
e.printStackTrace();
if(conn!=null){
try {
conn.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if(Hadmin!=null){
try {
Hadmin.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
public boolean createTable(String tableName,String columnFamily){
/**
* create table
* here I limit the number of column family to 1
* So here only can create one column family's table
* **/
TableName table_name= TableName.valueOf(tableName);
LOG.info("Create table:"+tableName+" now!");
HTableDescriptor tableDesc=new HTableDescriptor(table_name);
HColumnDescriptor columnDesc=new HColumnDescriptor(columnFamily);
tableDesc.addFamily(columnDesc);
try {
this.Hadmin.createTable(tableDesc);
} catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
public boolean writeOne(HashMap<String,String> data,String[] keys, String tableName,String columnFamily){
/**
* write one data to table at one time
* here I choose the first key as the rowKey,because I think the first key usually is the primary key
* **/
boolean flag=false;
TableName table_name=TableName.valueOf(tableName);
byte[] column_family=columnFamily.getBytes();
try {
Table table=conn.getTable(table_name);
byte[] rowKey=data.get(keys[0]).toString().getBytes(); //construct HBase table's rowKey
Put put=new Put(rowKey);
for(int i=0;i<keys.length;i++){
byte[] key=keys[i].getBytes();
byte[] value=data.get(keys[i]).toString().getBytes();
put.addColumn(column_family,key,value);
}
table.put(put);
table.close();
flag=true;
} catch (IOException e) {
e.printStackTrace();
}
return flag;
}
public void close(){
/**
* close connection
* **/
LOG.info("Close connection to HBase!");
if(Hadmin!=null){
try {
Hadmin.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
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
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
到此，工具類已經基本完成，下面需要寫一個主類：

public class deMain {
public static void main(String[] args){
//JDBC Init
Connection conn=null;
String sql="select * from Info";
String databaseName="test";
String userName="root";
String password="****";
String url="jdbc:mysql://localhost:3306/"+databaseName+"?user="+userName+"&password="
+password+"&useUnicode=true&characterEncoding=utf-8";
//HBase Client Init
String tableName="test";
String columnFamily="info";
Configuration conf= HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum","127.0.0.1");
conf.set("hbase.master","localhost:9000");
}
//JDBC connection and read data
JDBCUtils ju=new JDBCUtils(databaseName,userName,password,url);
ju.connect();
ResultSet rs=ju.readData(sql);
//HBase connect
HBaseUtils hbu=new HBaseUtils(conf);
hbu.connect();
//依次讀取rs中每條記錄，並將其寫入HBase相應表中即可
.........
//close all connection
hbu.close();
ju.close();
}
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
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
到此，大功告成！由於是通過IDE端運行hadoop程序，所以我們需要將需要用到的依賴庫導入，而這個過程如果不藉助maven的話，就會特別的痛苦。下圖是我配置的項目依賴包，僅供參考。
這里寫圖片描述
註：hadoop2.7.2,hbase1.2.1,zookeeper3.4.6

⑦ HBase是什麼呢，都有哪些特點呢

Hbase是一種NoSQL資料庫，這意味著它不像傳統的RDBMS資料庫那樣支持SQL作為查詢語言。Hbase是一種分布式存儲的資料庫，技術上來講，它更像是分布式存儲而不是分布式資料庫，它缺少很多RDBMS系統的特性，比如列類型，輔助索引，觸發器，和高級查詢語言等待

那Hbase有什麼特性呢？如下：

強讀寫一致，但是不是「最終一致性」的數據存儲，這使得它非常適合高速的計算聚合
自動分片，通過Region分散在集群中，當行數增長的時候，Region也會自動的切分和再分配
自動的故障轉移
Hadoop/HDFS集成，和HDFS開箱即用，不用太麻煩的銜接
豐富的「簡潔，高效」API，Thrift/REST API，Java API
塊緩存，布隆過濾器，可以高效的列查詢優化
操作管理，Hbase提供了內置的web界面來操作，還可以監控JMX指標

什麼時候用Hbase？

Hbase不適合解決所有的問題：

首先資料庫量要足夠多，如果有十億及百億行數據，那麼Hbase是一個很好的選項，如果只有幾百萬行甚至不到的數據量，RDBMS是一個很好的選擇。因為數據量小的話，真正能工作的機器量少，剩餘的機器都處於空閑的狀態
其次，如果你不需要輔助索引，靜態類型的列，事務等特性，一個已經用RDBMS的系統想要切換到Hbase，則需要重新設計系統。
最後，保證硬體資源足夠，每個HDFS集群在少於5個節點的時候，都不能表現的很好。因為HDFS默認的復制數量是3，再加上一個NameNode。

Hbase在單機環境也能運行，但是請在開發環境的時候使用。

內部應用

存儲業務數據:車輛GPS信息，司機點位信息，用戶操作信息，設備訪問信息。。。
存儲日誌數據:架構監控數據（登錄日誌，中間件訪問日誌，推送日誌，簡訊郵件發送記錄。。。），業務操作日誌信息
存儲業務附件：UDFS系統存儲圖像，視頻，文檔等附件信息

不過在公司使用的時候，一般不使用原生的Hbase API，使用原生的API會導致訪問不可監控，影響系統穩定性，以致於版本升級的不可控。

HFile

HFile是Hbase在HDFS中存儲數據的格式，它包含多層的索引，這樣在Hbase檢索數據的時候就不用完全的載入整個文件。索引的大小(keys的大小，數據量的大小)影響block的大小，在大數據集的情況下，block的大小設置為每個RegionServer 1GB也是常見的。

探討資料庫的數據存儲方式，其實就是探討數據如何在磁碟上進行有效的組織。因為我們通常以如何高效讀取和消費數據為目的，而不是數據存儲本身。

Hfile生成方式

起初，HFile中並沒有任何Block，數據還存在於MemStore中。

Flush發生時，創建HFile Writer，第一個空的Data Block出現，初始化後的Data Block中為Header部分預留了空間，Header部分用來存放一個Data Block的元數據信息。

而後，位於MemStore中的KeyValues被一個個append到位於內存中的第一個Data Block中：

註：如果配置了Data Block Encoding，則會在Append KeyValue的時候進行同步編碼，編碼後的數據不再是單純的KeyValue模式。Data Block Encoding是HBase為了降低KeyValue結構性膨脹而提供的內部編碼機制。

⑧ 如何使用hbase搭建知識共享平台

HBase來源於google的一篇論文BigTable，後來由Apache做了開源實現就是HBase。是一種NoSQL、非關系型的資料庫、不符合關系型資料庫的範式。

適合存儲半結構化、非結構化的數據；適合存儲稀疏的數據，稀疏的數據中空的數據不佔用空間。

面向列(族)進行存儲，提供實時增刪改查的能力，是一種真正的資料庫。

可以存儲海量數據、性能也很強大，可以實現上億條記錄的毫秒級別的查詢，但是不能提供嚴格的事務控制，只能在行級別保證事務。

HBase是一個高可靠性、高性能、面向列、可伸縮的分布式存儲系統，利用hbase技術可以在廉價的PC上搭建起大規模結構化存儲集群。

HBase利用Hadoop HDFS作為其文件存儲系統，利用Hadoop的MapRece來處理HBase中的海量數據，利用Zookeeper作為協調工具。

2、

⑨ hbase無法創建資料庫

猜測您想問的是hbase無法創建資料庫，什麼原因？沒有配置host映射，java找不到對應虛擬機。
參考博客網站提供的資料顯示hbase無法創建資料庫原因是沒有配置host映射，java找不到對應虛擬機，可以通過添加虛擬機ip地址、加虛擬機名進行解決。
HBase是一個分布式的、面向列的開源資料庫。

hbase創建資料庫

與hbase創建資料庫相關的內容