HBASE总结

最新推荐文章于 2022-04-10 23:05:31 发布
最新推荐文章于 2022-04-10 23:05:31 发布
阅读量347 收藏
点赞数
分类专栏： 大数据 文章标签： 大数据 hbase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwk_sys/article/details/105149033
版权

目录

HBASE基本知识点

  1. HBASE是一个分布式的，列式数据库
  2. HBASE中的行由行键和一个或多个列组成，行键类似于关系型数据库的主键索引，按照字母顺序排序
  3. HBASE中列族由一个或多个列组成，可以理解为将列进行分组，列族一般不超过3个
  4. HBASE中单元格，类似于关系型数据库中某个字段的值，是通过行键，列族，列三者来定位，单元格包含数据和时间戳，数据类型为字节数据byte[]类型，时间戳代表版本
  5. 可将HBASE理解为一个类似于键值对的数据库，通过行键，列族，列，时间戳可以定位到具体的单元格，时间戳可省略，因为默认取最新的数据

HBASE集群架构

HBASE架构采用主从方式，类似于HDFS的namenode和datanode，HBASE集群由HMaster节点、HRegionServer节点、ZooKeeper集群组成，所有节点通过zookeeper协调，HMaster通过ZooKeeper获取HRegionServer的状态并进行管理，底层通过HRegionServer将数据存储在HDFS中

HBASE SHELL基本命令

操作命令注意
建表create ‘t1’,‘f1’建表时需同时指定表名t1和列族名称f1
添加数据put ‘t1’,‘row1’,‘f1:name’,‘zhangsan’表 t1,行键 row1,列族及列 f1:name,值 zhangsan
全表扫描scan ‘t1’表名 t1
查询某一行get ‘t1’,‘row1’表名 t1,行键 row1
修改表中数据put ‘t1’,‘row1’,‘f1:name’,lisi’表名 t1，行键 row1，列族及列 f1:name,值 lisi
删除特定单元格delete ‘t1’,‘row1’,‘f1:name’表名 t1，行键 row1，列族及列 f1:name
删除一整行deleteall ‘t1’,‘row2’表名 t1，行键 row2
禁用表disable ‘t1’
删除整张表drop ‘t1’若要完全删除一张表，需先执行disable，再执行drop
列出所有表list
查询表中行数count ‘t1’
判断表是否存在exists ‘t1’

HBASE JAVA API操作

创建表
package walker_0325;

import java.io.IOException;

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.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;

public class HbaseCreateTable {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		//创建hbase配置对象
		Configuration conf = HBaseConfiguration.create();
		
		//指定zookeeper集群地址
		conf.set("hbase.zookeeper.quorum", "192.168.220.129:2181,192.168.220.130:2181,192.168.220.131:2181");
		
		//创建连接对象connection
		Connection conn = ConnectionFactory.createConnection(conf);
		
		//得到数据库管理员对象
		Admin admin = conn.getAdmin();
		
		//创建表描述，并指定表名
		TableName tableName = TableName.valueOf("t2");
		HTableDescriptor desc = new HTableDescriptor(tableName);
		
		//创建列族描述
		HColumnDescriptor family = new HColumnDescriptor("f2");
		
		//指定列族
		desc.addFamily(family);
		
		//创建表
		admin.createTable(desc);
		System.out.println("create table success");
		
	}

}

建表整体上可认为分两步进行，即 配环境连库，管理员建表
配环境连库：

  1. 操作HBASE，需配置HBASE环境，HBaseConfiguration.create();
  2. HBASE通过zookeeper实现节点间协调， conf.set(“hbase.zookeeper.quorum”,“集群…”);
  3. 连接数据库，ConnectionFactory.createConnection(conf);

管理员建表：

  1. 获取管理员用户，conn.getAdmin();
  2. 设置表名及表描述，new HTableDescriptor(TableName.valueOf(“t2”));
  3. 列族描述，new HColumnDescriptor(“f2”);
  4. 表与列族关联，desc.addFamily(family);
  5. 管理员建表，admin.createTable(desc);
添加数据
package walker_0325;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

/**
 * @author Administrator
 * @date 2020年3月25日 上午10:53:59
 * 向hbase表中添加数据
 */
public class HBasePutData {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		//创建HBASE配置对象
		Configuration conf = HBaseConfiguration.create();
		
		//指定zookeeper集群地址
		conf.set("hbase.zookeeper.quorum", "192.168.220.129:2181,192.168.220.130:2181,192.168.220.131:2181");
		
		//创建数据库连接对象connection
		Connection conn = ConnectionFactory.createConnection(conf);
		
		//Table负责与记录相关的操作，如增删改查等
		TableName tableName = TableName.valueOf("t2");
		Table table = conn.getTable(tableName);
		
		//设置rowkey
		Put put = new Put(Bytes.toBytes("row1"));
		
		//添加列数据，指定列族，列名，列值
		put.addColumn(Bytes.toBytes("f2"), Bytes.toBytes("name"), Bytes.toBytes("xiaoming"));
		put.addColumn(Bytes.toBytes("f2"), Bytes.toBytes("age"), Bytes.toBytes("20"));
		put.addColumn(Bytes.toBytes("f2"), Bytes.toBytes("address"), Bytes.toBytes("beijing"));
		
		
		//设置rowkey
		Put put2 = new Put(Bytes.toBytes("row2"));
		
		//添加列数据，指定列族，列名，列值
		put2.addColumn(Bytes.toBytes("f2"), Bytes.toBytes("name"), Bytes.toBytes("xiaoming2"));
		put2.addColumn(Bytes.toBytes("f2"), Bytes.toBytes("age"), Bytes.toBytes("22"));
		put2.addColumn(Bytes.toBytes("f2"), Bytes.toBytes("address"), Bytes.toBytes("beijing2"));		

		
		//设置rowkey
		Put put3 = new Put(Bytes.toBytes("row3"));
		
		//添加列数据，指定列族，列名，列值
		put3.addColumn(Bytes.toBytes("f2"), Bytes.toBytes("age"), Bytes.toBytes("25"));
		put3.addColumn(Bytes.toBytes("f2"), Bytes.toBytes("address"), Bytes.toBytes("beijing3"));		
		
		
		//执行添加数据
		table.put(put);
		table.put(put2);
		table.put(put3);
		
		//释放资源
		table.close();
		
		System.out.println("put data success");
	}
}

整体上也可认为分两步进行，即配环境连库，put对象装数
配环境连库：与建表一致，HBASE配置，zookeeper配置，连库
put对象装数：

  1. 先得知道往哪个表里装，conn.getTable(TableName.valueOf(“t2”));
  2. 指定rowkey，建立put对象，Put put = new Put(Bytes.toBytes(“row1”));
  3. 指定列族，列名，值，添加数据，put.addColumn(Bytes.toBytes(“f2”), Bytes.toBytes(“name”), Bytes.toBytes(“xiaoming”));
查询数据
package walker_0325;

import java.io.IOException;

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.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Table;

/**
 * @author Administrator
 * @date 2020年3月25日 上午11:13:04
 * 查询表t2行键为row1的一行数据
 */
public class HBaseGetData {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		//创建hbase配置对象
		Configuration conf = HBaseConfiguration.create();
		
		//指定zookeeper集群地址
		conf.set("hbase.zookeeper.quorum", "192.168.220.129:2181,192.168.220.130:2181,192.168.220.131:2181");
		
		//获得数据库连接
		Connection conn = ConnectionFactory.createConnection(conf);
		
		//获得Table对象，指定查询表名，Table负责与记录相关的操作，如增删改查等
		Table table = conn.getTable(TableName.valueOf("t2"));
		
		//创建Get对象，根据rowkey查询，rowkey=row1
		Get get = new Get("row1".getBytes());
		
		//查询数据，取得结果集
		Result r = table.get(get);
		
		//循环输出每个单元格的值
		for (Cell cell : r.rawCells()) {
			//取得当前单元格所属列族名称
			String family = new String(CellUtil.cloneFamily(cell));
			//取得当前单元格所属列名称
			String qualifier = new String(CellUtil.cloneQualifier(cell));
			//取得当前单元格的列值
			String value = new String(CellUtil.cloneValue(cell));
			//输出结果
			System.out.println("列族"+family+"; 列名"+qualifier+"; 值"+value);
			
		}
	}

}

整体上分三步，配环境连库，get对象取一行，foreach取值
配环境连库，与前两个一致
get对象取一行

  1. 拿表名，conn.getTable(TableName.valueOf(“t2”));
  2. 指定rowkey，new Get(“row1”.getBytes());
  3. 取出数据集，table.get(get);

foreach取值
循环取到每个单元格的值

删除数据
package walker_0325;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
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.Table;
import org.apache.hadoop.hbase.util.Bytes;

/**
 * @author Administrator
 * @date 2020年3月25日 上午11:30:27
 * 删除表t2中行键为row1的一整条数据
 */
public class HBaseDeleteData {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		//创建hbase配置对象
		Configuration conf = HBaseConfiguration.create();
		
		//设置集群zookeeper
		conf.set("hbase.zookeeper.quorum", "192.168.220.129:2181,192.168.220.130:2181,192.168.220.131:2181");
		
		//创建connection对象
		Connection conn = ConnectionFactory.createConnection(conf);
		
		Table table = conn.getTable(TableName.valueOf("t2"));
		
		//创建删除对象delete，根据rowkey删除一整条 "row1".getBytes()
		Delete delete = new Delete(Bytes.toBytes("row1"));
		table.delete(delete);
		
		//释放资源
		table.close();
		System.out.println("删除完成");
		
	}

}

整体分两步，配环境连库，delete对象删数
配环境连库与之前一致
delete对象删数

  1. 拿表名，conn.getTable(TableName.valueOf(“t2”));
  2. 指定删除rowkey，new Delete(Bytes.toBytes(“row1”));
  3. 删除，table.delete(delete);

HBASE过滤器

package walker_0325;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
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.client.Table;
import org.apache.hadoop.hbase.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.FamilyFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.QualifierFilter;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueExcludeFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.filter.SubstringComparator;
import org.apache.hadoop.hbase.filter.ValueFilter;
import org.apache.hadoop.hbase.util.Bytes;

/**
 * @author Administrator
 * @date 2020年3月25日 下午3:54:35
 * 使用HDFS过滤器查询
 */
public class HBaseUseFilter {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		
		//HBase环境配置对象
		Configuration conf = HBaseConfiguration.create();
		
		//设置zookeeper集群信息
		conf.set("hbase.zookeeper.quorum", "192.168.220.129:2181,192.168.220.130:2181,192.168.220.131:2181");
		
		//创建connection对象建立连接
		Connection conn = ConnectionFactory.createConnection(conf);
		
		//获取表
		Table table = conn.getTable(TableName.valueOf("t2"));
		
		
		/**
		 * 1.行键过滤器
		 */
		System.out.println("行键过滤器");
		//创建Scan对象
		Scan scan = new Scan();
		//创建一个过滤器，筛选行键等于row1的数据
		RowFilter filter = new RowFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("row2")));
		//设置过滤器
		scan.setFilter(filter);
		//查询数据，返回结果数据集
		ResultScanner rs = table.getScanner(scan);
		for (Result res : rs) {
			System.out.println(res);
		}
		
		/**
		 * 2.列族过滤器
		 */
		System.out.println("列族过滤器");
		Scan scan2 = new Scan();
		//创建一个过滤器，筛选列族为f1的所有数据
		FamilyFilter filter2 = new FamilyFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("f2")));
		scan2.setFilter(filter2);
		ResultScanner rs2 = table.getScanner(scan2);
		for (Result result2 : rs2) {
			System.out.println(result2);
		}
		
		
		/**
		 * 3.列过滤器
		 */
		System.out.println("列过滤器");
		Scan scan3 = new Scan();
		QualifierFilter filter3 = new QualifierFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("address")));
		scan3.setFilter(filter3);
		ResultScanner rs3 = table.getScanner(scan3);
		for (Result result3 : rs3) {
			System.out.println(result3);
		}

		
		/**
		 * 4.值过滤器
		 */
		System.out.println("值过滤器");
		Scan scan4 = new Scan();
		ValueFilter filter4 = new ValueFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("xiaoming2")));
		scan4.setFilter(filter4);
		ResultScanner rs4 = table.getScanner(scan4);
		for (Result result4 : rs4) {
			System.out.println(result4);
		}
		
		/**
		 * 5.单列值过滤器
		 */
		//筛选出age列不为22的所有数据
		System.out.println("单列值过滤器");
		Scan scan5 = new Scan();
		Filter filter5 = new SingleColumnValueExcludeFilter(Bytes.toBytes("f2"),
				Bytes.toBytes("age"), 
				CompareOp.NOT_EQUAL, 
				new SubstringComparator("22"));
		//如果某行name列不存在，哪个该行将被过滤掉，false则不进行过滤，默认为false
		((SingleColumnValueFilter)filter5).setFilterIfMissing(true);
		scan5.setFilter(filter5);
		ResultScanner rs5 = table.getScanner(scan5);
		for (Result result5 : rs5) {
			System.out.println(result5);
		}
		
		
		/**
		 * 6.多条件过滤
		 */
		System.out.println("多条件过滤");
		Scan scan6 = new Scan();
		
		//创建过滤器，查询年龄<=30的所有数据
		Filter filter6 = new SingleColumnValueExcludeFilter(Bytes.toBytes("f2"), 
				Bytes.toBytes("age"), 
				CompareOp.LESS_OR_EQUAL, 
				Bytes.toBytes("30"));
		//创建过滤器，查询年龄>=16的所有数据
		Filter filter7 = new SingleColumnValueExcludeFilter(Bytes.toBytes("f2"), 
				Bytes.toBytes("age"), 
				CompareOp.GREATER_OR_EQUAL, 
				Bytes.toBytes("16"));
		
		//创建过滤器集合对象
		FilterList filterList = new FilterList();
		//添加过滤器
		filterList.addFilter(filter6);
		filterList.addFilter(filter7);
		
		scan6.setFilter(filterList);
		ResultScanner rs6 = table.getScanner(scan6);
		for (Result result6 : rs6) {
			System.out.println(result6);
		}
		
	}

}

过滤器可以理解为sql中的where条件
使用过滤器整体上四步走

  1. 创建scan对象
  2. 针对不同过滤创建过滤器
  3. scan设置过滤器
  4. 获取扫描结果
  5. foreach循环返回结果

HBASE MapReduce数据转移

不同表间数据转移
package walker_03252;

import java.io.IOException;

import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapper;
import org.apache.hadoop.hbase.util.Bytes;




/** map类
 * @author Administrator
 * @date 2020年3月25日 下午6:09:16
 * 从hbase中读取表student的指定列数据
 */
public class ReadStudentMapper extends TableMapper<ImmutableBytesWritable, Put>{

	/**
	 * 参数key为表中的行键，value为表中的一行数据
	 */
	@Override
	protected void map(ImmutableBytesWritable key, Result value,Context context)
			throws IOException, InterruptedException {
		// TODO Auto-generated method stub
		//新建put对象，传入行键
		Put put = new Put(key.get());
		//遍历一行数据的每一个单元格
		for (Cell cell: value.rawCells()) {
			//如果当前单元格所属列族为info
			if ("info".equals(Bytes.toString(CellUtil.cloneFamily(cell)))) {
				//如果当前单元格的列限定符为name
				if ("name".equals(Bytes.toString(CellUtil.cloneQualifier(cell)))) {
					//将该单元格加入到put对象中
					put.add(cell);
					//如果当前单元格的列限定符为age
				}else if ("age".equals(Bytes.toString(CellUtil.cloneQualifier(cell)))) {
					//将该单元格加入到put对象中
					put.add(cell);
				}
			}
		}
		
		//将put对象写入到context中作为map的输出
		context.write(key, put);
		
	}
}

TableMapper是Mapper类的简化版本，只有两个参数，输出key和输出value，因为输入key和输入value值是固定的，输入key为ImmutableBytesWritable，为hbase中的行键，输入value为Result，为hbase中的一行数据。

package walker_03252;

import java.io.IOException;

import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableReducer;
import org.apache.hadoop.io.NullWritable;

/** reduce类
 * @author Administrator
 * @date 2020年3月25日 下午6:20:39
 * 将数据写入到hbase另一张表student_new中
 */
public class WriteStudentReducer extends TableReducer<ImmutableBytesWritable, Put, NullWritable>{

	/**
	 * 接收map方法的输出，参数key和value的类型需与map方法的输出一致
	 */
	
	@Override
	protected void reduce(ImmutableBytesWritable key, Iterable<Put> values,Context context)
			throws IOException, InterruptedException {
		// TODO Auto-generated method stub
		for (Put put : values) {
			//将数据写入hbase表中，输出的key可以为空，因为行键在put对象中已经包含
			context.write(NullWritable.get(), put);
		}
	}
	
}

TableReducer是Reducer类的简化版本，泛型参数仅有输入key，输入value，输出key三个，输出value的类型是固定的，为HBASE抽象Mutation类型，Mutation有4个子类，分别为Append,Delete,Increment,Put，输出value只能是这四个中一个，

package walker_03252;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.mapreduce.Job;

/** 主类
 * @author Administrator
 * @date 2020年3月25日 下午7:13:00
 * mapreduce任务构建与执行类
 */
public class StudentMRRunner {

	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		// TODO Auto-generated method stub

		//创建configuration实例
		Configuration conf = HBaseConfiguration.create();
		
		//创建job任务，指定任务名称
		Job job = Job.getInstance(conf,"hbase_mr_job");
		//设置任务运行主类
		job.setJarByClass(StudentMRRunner.class);
		//创建Scan数据扫描对象
		Scan scan = new Scan();
		//是否缓存数据块，默认true，设置为false节省了交换缓存的操作消耗，可以提升MR任务的有效率
		scan.setCacheBlocks(false);
		//每次RPC请求从HBase表中取得的数据行数
		scan.setCaching(500);
		//初始化Mapper任务
		TableMapReduceUtil.initTableMapperJob("student", //数据源表名
				scan, //scan扫描控制器
				ReadStudentMapper.class, //指定mapper类
				ImmutableBytesWritable.class, //mapper的输出key类型
				Put.class, //mapper输出的value类型
				job //指定任务Job
				);
		//初始化reducer任务
		TableMapReduceUtil.initTableReducerJob("student_new", //数据目的地表名
				WriteStudentReducer.class, //指定reudcer类 
				job //指定任务Job
				);
		
		//设置reduce数量，最少1个
		job.setNumReduceTasks(1);
		//执行任务
		boolean isSuccess = job.waitForCompletion(true);
		
		if (!isSuccess) {
			throw new IOException("任务运行错误");
		}
		
		System.exit(isSuccess ? 0 : 1);
		
	}

}

与mapreduce不同的是，使用TableMapReduceUtil来进行初始化map和reduce任务。

HDFS数据转移至HBASE
//hdfs中数据
004	WangQiang	28
005	ZhaoLong	36
006	LiNing	27

package walker_03253;

import java.io.IOException;

import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;



/**
 * @author Administrator
 * @date 2020年3月25日 下午7:52:03
 * 读取HDFS中的文件student.txt的数据
 */
public class ReadHDFSStudentMapper extends Mapper<LongWritable, Text, ImmutableBytesWritable, Put> {

	/**
	 * 接收HDFS中的数据
	 * 参数key为一行数据的下标位置，value为一行数据
	 */
	
	@Override
	protected void map(LongWritable key, Text value,Context context)
			throws IOException, InterruptedException {
		// TODO Auto-generated method stub
		
		//将读取的一行数据转换为字符串
		String lineValue = value.toString();
		//将一行数据根据\t分割成String数组
		String[] values = lineValue.split("\t");
		//取出每一个值
		String rowKey = values[0];
		String name = values[1];
		String age = values[2];
		//将rowkey转化为ImmutableBytesWritable类型，便于reduce阶段接收
		ImmutableBytesWritable rowKeyWritable = new ImmutableBytesWritable(Bytes.toBytes(rowKey));
		//创建put对象，用于存储一整行数据
		Put put = new Put(Bytes.toBytes(rowKey));
		//向put对象中添加数据
		put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"), Bytes.toBytes(name));
		put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("age"), Bytes.toBytes(age));
		
		//写数据到reduce阶段，键为HBase表的rowkey(学号)，值为put对象
		context.write(rowKeyWritable, put);

	}
	
	
}

将数据存到string数组，再把行键转为对应类型，将行键和数据添加到put对象。

package walker_03253;

import java.io.IOException;

import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableReducer;
import org.apache.hadoop.io.NullWritable;



/**
 * @author Administrator
 * @date 2020年3月25日 下午8:07:40
 * 将接收到的数据写入到HBASE表中
 */
public class WriteHBaseStudentReducer extends TableReducer<ImmutableBytesWritable, Put, NullWritable> {

	/**
	 * 接收map方法的输出，参数key和value的类型需与map方法的输出一致
	 */
	@Override
	protected void reduce(ImmutableBytesWritable key, Iterable<Put> values,Context context)
			throws IOException, InterruptedException {
		// TODO Auto-generated method stub
		
		for (Put put : values) {
			//将数据写入hbase表，输出的key可以为空，因为行键在put对象中已经包含
			context.write(NullWritable.get(), put);
		}
	}
	
}


package walker_03253;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;

/**
 * @author Administrator
 * @date 2020年3月25日 下午8:19:11
 * mapreduce任务构建与执行类
 */
public class HDFS2HBaseMRRunner {

	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		// TODO Auto-generated method stub

		//创建hbase配置对象
		Configuration conf = HBaseConfiguration.create();
		//创建job并指定任务名称
		Job job = Job.getInstance(conf,"hbase_mr_job2");
		//设置任务运行主类
		job.setJarByClass(HDFS2HBaseMRRunner.class);
		
		//设置文件输入路径
		Path inputPath = new Path("hdfs://walker001:9000/test/0325/student.txt");
		//job与文件路径关联
		FileInputFormat.addInputPath(job, inputPath);
		
		//设置mapper类
		job.setMapperClass(ReadHDFSStudentMapper.class);
		//mapper类的输出key类型
		job.setMapOutputKeyClass(ImmutableBytesWritable.class);
		//mapper类的输出value类型
		job.setMapOutputValueClass(Put.class);
		
		//初始化reduce任务
		TableMapReduceUtil.initTableReducerJob("student_new",//目标表
				WriteHBaseStudentReducer.class,//reducer类 
				job //任务job
				);
		
		//设置reduce任务数量
		job.setNumReduceTasks(1);
		
		//执行任务
		
		boolean isSuccess = job.waitForCompletion(true);
		
		if (!isSuccess) {
			throw new IOException("任务运行异常");
		}
		
		System.exit(isSuccess ? 0 : 1);
		

	}

}
寻找你的海洋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HBase总结(超详细)
01-24
分数不让我设定(最好是0)包含原理概念、架构、单机安装、分布式安装，HBase的优化及Phoenixd的一点拓展知识，二叉树，B树等等。。
Hbase总结.docx
09-13
在HBase这种分布式列式数据库中，Rowkey的设计至关重要，因为它直接影响着数据的分布和查询效率。以下是关于HBase Rowkey设计的一些关键知识点： 1. 唯一性原则：Rowkey必须确保全局唯一，避免数据冲突。这可以通过...
hbase个人总结
zhouben12的博客
09-03 465
概述 分布式非关系型数据库 列存储 可以存储大数据量 数据最后是落盘到hadoop上，廉价，便于横向拓展 没有主键的概念，行键Rowkey代替主键 数据写入不是覆盖，而是记录一个新的VERSION，默认显示最新VERSION的数据 namespace下有default和hbase两个自带的属性空间，hbase不要动，表默认写入default中。 列存储 写入数据的时候，行存储数据是连续的，只要尾部追加，而列存储需要多少寻址。行比列快 ...
【笔记】关于HBase的总结和疑问
ZoeYen_
11-28 685
1.HBase和HDFS的异同2.HBase按列存储 数据是按列存储的，每一列单独存放 数据即是索引 只访问查询涉及到的列，降低I/O 每一列由一个线索来处理-查询的并发处理 数据类型一致-高效压缩 3.HBase VS HFile4.HBase查询比Hive快的原因(1) Hive hive是基于mapreduce来处理数据，离线计算速度慢 mapreduce处理数是基于行的模式，查询数据默认是扫
HBASE精炼笔记总结—[基础篇]
RobertDowneyLm的博客
05-20 2850
1.  HBASE1.1. 1/ 什么是HBASE1.1.1.  概念特性HBASE是一个数据库----可以提供数据的实时随机读写 HBASE与mysql、oralce、db2、sqlserver等关系型数据库不同，它是一个NoSQL数据库（非关系型数据库）l  Hbase的表模型与关系型数据库的表模型不同：l  Hbase的表没有固定的字段定义；l  Hbase的表中每行存储的都是一些key-v...
大数据开发高薪训练营--HBase协处理
08-09 919
最近大数据技术陷入了瓶颈，偶然间发现拉钩大数据开发高薪训练营课程，主要是被他的用户画像匹配系统吸引，据说是用拉钩真实数据进行讲解。本来对一些基础知识包括mapreduce，hive，hbase等讲解没有报太多希望，没想到听了几节课后，我反而发现有很多知识点我这么多年都忽略了。市面上的很多课程我也都听了，讲的内容大多数都是只有宽度没有深度，拉钩教育确实与众不同，我想主要是他的授课模式的创新，类似好未来那种 名师讲解 + 小班答疑。拉钩教育便是采用的这种模式，知识点都是知名讲师先录好，学生在线自主...
HBase总结.xmind
最新发布
06-18
HBase是一个分布式的、可扩展的、面向列的存储系统，它是Apache软件基金会的一个开源项目，基于Google的BigTable模型构建。HBase运行在Hadoop生态系统之上，利用Hadoop的文件存储系统HDFS（Hadoop Distributed File ...
hbase学习-脑图总结
04-23
hbase学习-脑图总结，涵盖了大部分基础知识点，下个脑图查看器即可，方便大家学习
Hbase的工具类
reddy_Hu的博客
07-17 336
以下为hbase在java客户端中会用到的工具类: package com.doit.oneMore.tools; 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.had
分布式NoSQL列存储数据库HBASE（二）
夜归人的博客
06-25 434
分布式NoSQL列存储数据库HBASE（二） 知识点01： Hbase的功能和应用场景是什么？ 功能：分布式提供大数据量的随机和实时数据存储【读写】 应用：大数据量、高性能、高并发、按列存储、持久化大数据数据库【结构化或者半结构化】存储 为什么Hbase可以读写很快而且支持大数据量？ 读写很快：内存 大数据量：磁盘 Hbase：分布式内存 + 分布式磁盘 将刚写入的数据直接写入内存，等到内存达到一定阈值以后，将内存数据写入HDFS实现持久化存储 写：内存 读：内存 或者 磁盘 Hbase为
HBase常用操作-HBaseUtil
weixin_30367873的博客
06-20 203
package com.zhen.hbase; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.List; impor...
Hbase的Filter详解使用
Flyer的后花园
11-20 3330
转载: https://blog.csdn.net/lr131425/article/details/72676254 参数基础 有两个参数类在各类Filter中经常出现，统一介绍下： （1）比较运算符 CompareFilter.CompareOp 比较运算符用于定义比较关系，可以有以下几类值供选择： EQUAL                                  相等 GREA...
大数据总结【第四章：Hbase】
计忆芳华的博客
06-09 9860
简答题 1. HBase简介 HBase是一个高可靠、高性能、面向列、可伸缩的分布式数据库，是谷歌BigTable的开源实现，主要用来存储非结构化和半结构化的松散数据。HBase的目标是处理非常庞大的表，可以通过水平扩展的方式，利用廉价计算机集群处理由超过10亿行数据和数百万列元素组成的数据表 2. HBase 和传统关系数据库的区别 区别 传统关系数据库 HBase 数据类型 关系模型 数据模型 数据操作 插入、删除、更新、查询、多表连接 插入、查询、删除、清空，无法实现表与表之间关联
深入探讨HBase
星辰大数据的博客
03-07 749
HBASE基础 1. HBase简介 HBase是一个高可靠、高性能、面向列的，主要用于海量结构化和半结构化数据存储的分布式key-value存储系统。 它基于Google Bigtable开源实现，但二者有明显的区别：Google Bigtable基于GFS存储，通过MAPREDUCE处理存储的数据，通过chubby处理协同服务；而HBase底层存储基于hdfs，可以利用MapReduce、...
HBase详细总结
菜菜的大数据开发の路
04-10 5159
1 HBase 浅析 1.1 HBase 是啥 HBase 是一款面向列存储，用于存储处理海量数据的 NoSQL 数据库。它的理论原型是Google 的 BigTable 论文。你可以认为 HBase 是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统。 HBase 的存储是基于HDFS的，HDFS 有着高容错性的特点，被设计用来部署在低廉的硬件上，基于 Hadoop 意味着 HBase 与生俱来的超强的扩展性和吞吐量。 HBase 采用的时key/value的存储方式，这意味着，即使随着数据量的增大，
HBase
u010530712的博客
09-18 1851
1、HBase是一个稀疏、多维度、排序的映射表，这张表的索引是行键、列族、列限定符和时间戳 2、每个值是一个未经解释的字符串，没有数据类型 3、用户在表中存储数据，每一行都有一个可排序的行键和任意多的列   表：HBase采用表来组织数据，表由行和列组成，列划分为若干个列族 行：每个HBase表都由若干行组成，每个行由行键（row key）来标识 列族：一个HBase表备份组成许多"列...
anxiao的HBase的API
qq_43742212的博客
01-06 1543
HBase的java代码开发 熟练掌握通过使用java代码实现HBase数据库当中的数据增删改查的操作，特别是各种查询，熟练运用 第二步：开发javaAPI操作HBase表数据 1、创建表myuser public static void createTable() throws IOException { Configuration conf =new Configuration(...
spark运算结果写入hbase及优化
weixin_30294295的博客
02-26 249
在Spark中利用map-reduce或者spark sql分析了数据之后，我们需要将结果写入外部文件系统。 本文，以向Hbase中写数据，为例，说一下，Spark怎么向Hbase中写数据。 首先，需要说一下，下面的这个方法。 foreach (func) 最通用的输出操作，把func作用于从map-reduce生成的每一个RDD(spark sql生成的DataFrame可...
hbase 删除列族下的某一列_HBase总结
06-01
要删除HBase中列族下的某一列，可以使用以下步骤： 1. 打开HBase shell，使用`disable '<table_name>'`命令禁用表格。 2. 使用`alter '<table_name>', NAME => '<column_family_name>', delete => '<column_name>'`命令删除列族下的某一列。 3. 使用`enable '<table_name>'`命令启用表格。 例如，要删除名为`test_table`的表格中名为`test_family`的列族下的`test_column`列，可以使用以下命令： ``` disable 'test_table' alter 'test_table', NAME => 'test_family', delete => 'test_column' enable 'test_table' ``` 执行完以上步骤后，`test_family`列族下的`test_column`列将被删除。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值