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 中创建新表并导入数据。

[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创建数据库相关的内容