通用MapReduce程序复制HBase表数据

最新推荐文章于 2023-03-06 07:58:53 发布
最新推荐文章于 2023-03-06 07:58:53 发布
阅读量886 收藏
点赞数 1
分类专栏： Hadoop 文章标签： hadoop mapreduce HBase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Angelababy_huan/article/details/53236693
版权

  编写MR程序，让其可以适合大部分的HBase表数据导入到HBase表数据。其中包括可以设置版本数、可以设置输入表的列导入设置(选取其中某几列)、可以设置输出表的列导出设置(选取其中某几列)。

  原始表test1数据如下：


 每个row key都有两个版本的数据，这里只显示了row key为1的数据

 在hbase shell 中创建数据表：

create 'test2',{NAME => 'cf1',VERSIONS => 10}    // 保存无版本、无列导入设置、无列导出设置的数据
create 'test3',{NAME => 'cf1',VERSIONS => 10}    // 保存无版本、无列导入设置、有列导出设置的数据
create 'test4',{NAME => 'cf1',VERSIONS => 10}    // 保存无版本、有列导入设置、无列导出设置的数据
create 'test5',{NAME => 'cf1',VERSIONS => 10}    // 保存有版本、无列导入设置、无列导出设置的数据
create 'test6',{NAME => 'cf1',VERSIONS => 10}    // 保存有版本、无列导入设置、有列导出设置的数据
create 'test7',{NAME => 'cf1',VERSIONS => 10}    // 保存有版本、有列导入设置、无列导出设置的数据
create 'test8',{NAME => 'cf1',VERSIONS => 10}    // 保存有版本、有列导入设置、有列导出设置的数据
 main函数入口： 

package GeneralHBaseToHBase;
import org.apache.hadoop.util.ToolRunner;
public class DriverTest {
	public static void main(String[] args) throws Exception {
		// 无版本设置、无列导入设置，无列导出设置
		String[] myArgs1= new String[]{
				"test1", // 输入表
				"test2", // 输出表
				"0",     // 版本大小数，如果值为0，则为默认从输入表导出最新的数据到输出表
				"-1",    // 列导入设置，如果为-1 ，则没有设置列导入
				"-1"	// 列导出设置，如果为-1，则没有设置列导出
			};			
		ToolRunner.run(HBaseDriver.getConfiguration(), 
				new HBaseDriver(),
				myArgs1);
		// 无版本设置、有列导入设置，无列导出设置
		String[] myArgs2= new String[]{
				"test1",
				"test3",
				"0",
				"cf1:c1,cf1:c2,cf1:c10,cf1:c11,cf1:c14",
				"-1"
			};
		ToolRunner.run(HBaseDriver.getConfiguration(), 
				new HBaseDriver(),
				myArgs2);
		// 无版本设置，无列导入设置，有列导出设置
		String[] myArgs3= new String[]{
				"test1",
				"test4",
				"0",
				"-1",
				"cf1:c1,cf1:c10,cf1:c14"
			};
		ToolRunner.run(HBaseDriver.getConfiguration(), 
				new HBaseDriver(),
				myArgs3);
		// 有版本设置，无列导入设置，无列导出设置
		String[] myArgs4= new String[]{
				"test1",
				"test5",
				"2",
				"-1",
				"-1"
			};
		ToolRunner.run(HBaseDriver.getConfiguration(), 
				new HBaseDriver(),
				myArgs4);
		// 有版本设置、有列导入设置，无列导出设置
		String[] myArgs5= new String[]{
				"test1",
				"test6",
				"2",
				"cf1:c1,cf1:c2,cf1:c10,cf1:c11,cf1:c14",
				"-1"
			};
		ToolRunner.run(HBaseDriver.getConfiguration(), 
				new HBaseDriver(),
				myArgs5);
		
		// 有版本设置、无列导入设置，有列导出设置
		String[] myArgs6= new String[]{
				"test1",
				"test7",
				"2",
				"-1",
				"cf1:c1,cf1:c10,cf1:c14"
			};
		ToolRunner.run(HBaseDriver.getConfiguration(), 
				new HBaseDriver(),
				myArgs6);
		// 有版本设置、有列导入设置，有列导出设置
		String[] myArgs7= new String[]{
				"test1",
				"test8",
				"2",
				"cf1:c1,cf1:c2,cf1:c10,cf1:c11,cf1:c14",
				"cf1:c1,cf1:c10,cf1:c14"
			};
		ToolRunner.run(HBaseDriver.getConfiguration(), 
				new HBaseDriver(),
				myArgs7);
	}

}
  driver： 

package GeneralHBaseToHBase;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
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;
import org.apache.hadoop.util.Tool;
import util.JarUtil;


public class HBaseDriver extends Configured implements Tool{
	public static String FROMTABLE=""; //导入表
	public static String TOTABLE="";  //导出表
	public static String SETVERSION=""; //是否设置版本
	// args => {FromTable,ToTable,SetVersion,ColumnFromTable,ColumnToTable}
	@Override
	public int run(String[] args) throws Exception {
		if(args.length!=5){
			System.err.println("Usage:\n demo.job.HBaseDriver <input> <inputTable> "
					+ "<output> <outputTable>"
					+"< versions >"
					+ " <set columns from inputTable> like <cf1:c1,cf1:c2,cf1:c10,cf1:c11,cf1:c14> or <-1> "
					+ "<set columns from outputTable> like <cf1:c1,cf1:c10,cf1:c14> or <-1>");
			return -1;
		}
		Configuration conf = getConf();
		FROMTABLE = args[0];
		TOTABLE = args[1];
		SETVERSION = args[2];
		conf.set("SETVERSION", SETVERSION);
		if(!args[3].equals("-1")){
			conf.set("COLUMNFROMTABLE", args[3]);
		}
		if(!args[4].equals("-1")){
			conf.set("COLUMNTOTABLE", args[4]);
		}
		String jobName ="From table "+FROMTABLE+ " ,Import to "+ TOTABLE;
		Job job = Job.getInstance(conf, jobName);
		job.setJarByClass(HBaseDriver.class);
		Scan scan = new Scan();
		// 判断是否需要设置版本
		if(SETVERSION != "0" || SETVERSION != "1"){
			scan.setMaxVersions(Integer.parseInt(SETVERSION));
		}
		// 设置HBase表输入：表名、scan、Mapper类、mapper输出键类型、mapper输出值类型
		TableMapReduceUtil.initTableMapperJob(
				FROMTABLE, 
				scan, 
				HBaseToHBaseMapper.class, 
				ImmutableBytesWritable.class, 
				Put.class, 
				job);
		// 设置HBase表输出：表名，reducer类
		TableMapReduceUtil.initTableReducerJob(TOTABLE, null, job);
		// 没有 reducers，  直接写入到 输出文件
	    job.setNumReduceTasks(0);
	 
        return job.waitForCompletion(true) ? 0 : 1;
        
	}
	private static Configuration configuration;
	public static Configuration getConfiguration(){
		if(configuration==null){
			/**
			 * TODO 了解如何直接从Windows提交代码到Hadoop集群
			 *      并修改其中的配置为实际配置
			 */
			configuration = new Configuration();
			configuration.setBoolean("mapreduce.app-submission.cross-platform", true);// 配置使用跨平台提交任务
			configuration.set("fs.defaultFS", "hdfs://master:8020");// 指定namenode
			configuration.set("mapreduce.framework.name", "yarn"); // 指定使用yarn框架
			configuration.set("yarn.resourcemanager.address", "master:8032"); // 指定resourcemanager
			configuration.set("yarn.resourcemanager.scheduler.address", "master:8030");// 指定资源分配器
			configuration.set("mapreduce.jobhistory.address", "master:10020");// 指定historyserver
			configuration.set("hbase.master", "master:16000");
			configuration.set("hbase.rootdir", "hdfs://master:8020/hbase");
			configuration.set("hbase.zookeeper.quorum", "slave1,slave2,slave3");
			configuration.set("hbase.zookeeper.property.clientPort", "2181");
			//TODO 需export->jar file ; 设置正确的jar包所在位置
			configuration.set("mapreduce.job.jar",JarUtil.jar(HBaseDriver.class));// 设置jar包路径
		}
		
		return configuration;
	}


}
  mapper： 

package GeneralHBaseToHBase;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.NavigableMap;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.KeyValue;
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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HBaseToHBaseMapper extends TableMapper<ImmutableBytesWritable, Put> {
	Logger log = LoggerFactory.getLogger(HBaseToHBaseMapper.class);
	private static int versionNum = 0;
	private static String[] columnFromTable = null;
	private static String[] columnToTable = null;
	private static String column1 = null;
	private static String column2 = null;
	@Override
	protected void setup(Context context)
			throws IOException, InterruptedException {
		Configuration conf = context.getConfiguration();
		versionNum = Integer.parseInt(conf.get("SETVERSION", "0"));
		column1 = conf.get("COLUMNFROMTABLE",null);
		if(!(column1 == null)){
			columnFromTable = column1.split(",");
		}
		column2 = conf.get("COLUMNTOTABLE",null); 
		if(!(column2 == null)){
			columnToTable = column2.split(",");
		}
	}
	@Override
	protected void map(ImmutableBytesWritable key, Result value,
			Context context)
			throws IOException, InterruptedException {
		context.write(key, resultToPut(key,value));
	}	
	/***
	 * 把key，value转换为Put
	 * @param key
	 * @param value
	 * @return
	 * @throws IOException
	 */
	private Put resultToPut(ImmutableBytesWritable key, Result value) throws IOException {
		HashMap<String, String> fTableMap = new HashMap<>();
		HashMap<String, String> tTableMap = new HashMap<>();
		Put put = new Put(key.get());
		if(! (columnFromTable == null || columnFromTable.length == 0)){
			fTableMap = getFamilyAndColumn(columnFromTable);
		}
		if(! (columnToTable == null || columnToTable.length == 0)){
			tTableMap = getFamilyAndColumn(columnToTable);
		}
		if(versionNum==0){                        
			if(fTableMap.size() == 0){            
				if(tTableMap.size() == 0){		  
					for (Cell kv : value.rawCells()) {
						put.add(kv);	// 没有设置版本，没有设置列导入，没有设置列导出
					}
					return put;
				} else{
					return getPut(put, value, tTableMap); // 无版本、无列导入、有列导出
				}
			} else {
				if(tTableMap.size() == 0){
					return getPut(put, value, fTableMap);// 无版本、有列导入、无列导出
				} else {
					return getPut(put, value, tTableMap);// 无版本、有列导入、有列导出
				}
			}
		} else{
			if(fTableMap.size() == 0){
				if(tTableMap.size() == 0){
					return getPut1(put, value); // 有版本，无列导入，无列导出
				}else{
					return getPut2(put, value, tTableMap); //有版本，无列导入，有列导出
				}
			}else{
				if(tTableMap.size() == 0){
					return getPut2(put,value,fTableMap);// 有版本，有列导入，无列导出
				}else{
					return getPut2(put,value,tTableMap); // 有版本，有列导入，有列导出
				}
			}
		}
	}
	/***
	 * 无版本设置的情况下，对于有列导入或者列导出
	 * @param put
	 * @param value
	 * @param tableMap
	 * @return
	 * @throws IOException
	 */

	private Put getPut(Put put,Result value,HashMap<String, String> tableMap) throws IOException{
		for(Cell kv : value.rawCells()){
			byte[] family = kv.getFamily();
			if(tableMap.containsKey(new String(family))){
				String columnStr = tableMap.get(new String(family));
				ArrayList<String> columnBy = toByte(columnStr);
				if(columnBy.contains(new String(kv.getQualifier()))){
					put.add(kv); //没有设置版本，没有设置列导入，有设置列导出
				}
			}
		}
		return put;
	}
	/***
	 * (有版本，无列导入，有列导出)或者(有版本，有列导入，无列导出)
	 * @param put
	 * @param value
	 * @param tTableMap
	 * @return
	 */
	private Put getPut2(Put put,Result value,HashMap<String, String> tableMap){
		NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> map=value.getMap();
        for(byte[] family:map.keySet()){
        	if(tableMap.containsKey(new String(family))){
        		String columnStr = tableMap.get(new String(family));
        		log.info("@@@@@@@@@@@"+new String(family)+"   "+columnStr);
				ArrayList<String> columnBy = toByte(columnStr);
        		NavigableMap<byte[], NavigableMap<Long, byte[]>> familyMap = map.get(family);//列簇作为key获取其中的列相关数据
                for(byte[] column:familyMap.keySet()){                              //根据列名循坏
                    log.info("!!!!!!!!!!!"+new String(column));
                	if(columnBy.contains(new String(column))){
	                	NavigableMap<Long, byte[]> valuesMap = familyMap.get(column);
	                    for(Entry<Long, byte[]> s:valuesMap.entrySet()){//获取列对应的不同版本数据，默认最新的一个
	                    	System.out.println("***:"+new String(family)+"  "+new String(column)+"  "+s.getKey()+"  "+new String(s.getValue()));
	                    	put.addColumn(family, column, s.getKey(),s.getValue());
	                    }
                    }
                }
        	}
            
        }
		return put;		
	}
	/***
	 * 有版本、无列导入、无列导出
	 * @param put
	 * @param value
	 * @return
	 */
	private Put getPut1(Put put,Result value){
		NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> map=value.getMap();
        for(byte[] family:map.keySet()){    
            NavigableMap<byte[], NavigableMap<Long, byte[]>> familyMap = map.get(family);//列簇作为key获取其中的列相关数据
            for(byte[] column:familyMap.keySet()){                              //根据列名循坏
                NavigableMap<Long, byte[]> valuesMap = familyMap.get(column);
                for(Entry<Long, byte[]> s:valuesMap.entrySet()){                //获取列对应的不同版本数据，默认最新的一个
                	put.addColumn(family, column, s.getKey(),s.getValue());
                }
            }
        }
        return put;
	}
	// str => {"cf1:c1","cf1:c2","cf1:c10","cf1:c11","cf1:c14"}
	/***
	 * 得到列簇名与列名的k,v形式的map
	 * @param str => {"cf1:c1","cf1:c2","cf1:c10","cf1:c11","cf1:c14"}
	 * @return map => {"cf1" => "c1,c2,c10,c11,c14"}
	 */
	private static HashMap<String, String> getFamilyAndColumn(String[] str){
		HashMap<String, String> map = new HashMap<>();
		HashSet<String> set = new HashSet<>();
		for(String s : str){
			set.add(s.split(":")[0]);
		}
		Object[] ob = set.toArray();
		for(int i=0; i<ob.length;i++){
			String family = String.valueOf(ob[i]);
			String columns = "";
			for(int j=0;j < str.length;j++){
				if(family.equals(str[j].split(":")[0])){
					columns += str[j].split(":")[1]+",";
				}
			}
			map.put(family, columns.substring(0, columns.length()-1));
		}
		return map;		
	}
	
	private static ArrayList<String> toByte(String s){
		ArrayList<String> b = new ArrayList<>();
		String[] sarr = s.split(",");
		for(int i=0;i<sarr.length;i++){
			b.add(sarr[i]);
		}
		return b;
	}
}

  程序运行完之后，在hbase shell中查看每个表，看是否数据导入正确：

  test2：(无版本、无列导入设置、无列导出设置)


test3 (无版本、有列导入设置("cf1:c1,cf1:c2,cf1:c10,cf1:c11,cf1:c14")、无列导出设置)

 test4(无版本、无列导入设置、有列导出设置("cf1:c1,cf1:c10,cf1:c14"))

 

 test5(有版本、无列导入设置、无列导出设置)

 

 

 test6(有版本、有列导入设置("cf1:c1,cf1:c2,cf1:c10,cf1:c11,cf1:c14")、无列导出设置)

 

  test7(有版本、无列导入设置、有列导出设置("cf1:c1,cf1:c10,cf1:c14"))

test8(有版本、有列导入设置("cf1:c1,cf1:c2,cf1:c10,cf1:c11,cf1:c14")、有列导出设置("cf1:c1,cf1:c10,cf1:c14"))


Angelababy_huan
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hbase表复制 借助hive
yy的博客
09-12 199
hive hbase
hbase 复制表数据
lzlnd的博客
04-14 1761
使用CopyTable同步HBase数据 CopyTable是Hbase提供的一个数据同步工具，可以用于同步表的部分或全部数据 使用步骤： 1.创建目标表。表的列族和原表列族保持一致。如果不一致可以修改 先增加新的：alter '表名',{NAME=>'cf1'} 后删除旧的：alter '表名','delete'=>'CF' 2.进入到hbase的bin目录下执行命令 ...
hbase shell复制表
weixin_37630333的博客
01-12 585
查询版本 verson 清空数据： truncate 't1' 删除表： disable 't1' drop 't1' 克隆表： 复制表A 快照hbase表：SV:MN_CHUFA snapshot 'SV:MN_CHUFA' , 'SNAPSHOT_MN_CHUFA_20210112' 从快照克隆一个表 clone_snapshot 'SNAPSHOT_MN_CHUFA_20210112','SV:MN_CHUFA_PRO' ...
hbase 快速复制一张表数据到另一张新表
Cocktail_py的博客
01-22 6391
# 创建原表快照 # snapshot 'namespace:sourceTable', 'snapshotName', {SKIP_FLUSH => true} snapshot 'namespace:sourcetablename' , 'namespace_sourcetablename_snapshot' # 将快照数据复制到另外一张新表 clone_snapshot 'namespace_sourcetablename_snapshot','namespace:sourcetablenam
hadoop入门测试数据
06-07
5. 实践项目：通过创建一个简单的MapReduce程序，对“data”中的数据进行统计分析，例如计算文件中单词的频率，或者找出最大、最小值。这将帮助你更好地理解Hadoop如何处理大数据。 6. 高级主题：随着对Hadoop的...
Hadoop Core(MapReduce + YARN + HDFS)_
08-27
HDFS遵循“分而治之”的策略，将大文件切分成多个块，这些数据块会被复制到集群的不同节点上，以确保数据的可靠性。HDFS具有高吞吐量的特点，适合大规模批处理任务。 **HBase**是建立在HDFS之上的一种分布式、高...
大数据实习hdfs+flume+kafka+spark+hbase+hive项目.zip
最新发布
03-04
在实习项目中，Hive可以用于创建数据表，执行ETL（提取、转换、加载）操作，以及进行复杂的查询和报表生成。 在"spring-hadoop-master"这个子目录中，我们可以看到使用Spring框架与Hadoop进行集成的相关代码。...
hbase 表数据迁移
xiao_jun_0820的专栏
06-05 6984
1 CopyTable 工具 用法： CopyTable is a utility that can copy part or of all of a table, either to the same cluster or another cluster. The target table must first exist. The usage is as follows: $ bin/h
hbase的详解
04-02
这个文件是由淘宝著名工程师讲解的hbase的应用和实践。
Hbase 的复制
晓晓的天空
03-06 1273
Hbase 的复制
Hadoop MapReduce之ReduceTask任务执行（一）：远程拷贝map输出
诡影苍穹的专栏
06-16 6128
reduce执行流程经历三个阶段：copy、sort、reduce，在第一阶段reduce任务会把map的输出拷贝至本地，通过线程MapOutputCopier，该线程通过http协议将map输出拷贝至本地，该copy操作可以并行进行，默认情况下有5个线程执行此操作，如果map数量较大时可以适当调大此值，拷贝时使用http协议，此时reducetask为client，map端以jetty作为web
复制HBase表的数据到新表
哈
03-11 1514
准备工作 1.在HBase中创建一个名为fruit的表作为源表，如下： 2. 在HBase中再创建一个名为fruit2的表作为目标表，如下： 3. 往表中添加几组数据 创建Mapper public class FruitMapper extends TableMapper<ImmutableBytesWritable, Put> { @Override prot...
java导出hbase表数据_通用MapReduce程序复制HBase表数据
weixin_36151066的博客
02-25 271
编写MR程序，让其可以适合大部分的HBase表数据导入到HBase表数据。其中包括可以设置版本数、可以设置输入表的列导入设置(选取其中某几列)、可以设置输出表的列导出设置(选取其中某几列)。原始表test1数据如下：每个row key都有两个版本的数据，这里只显示了row key为1的数据在hbase shell 中创建数据表：create 'test2',{NAME => 'cf1',VE...
第十六记·Java操作MapReduce对HBase表进行数据迁移
玖局下半的博客
07-27 821
XY个人记 HBase集成MapReduce进行数据迁移工作，通过Java代码将HBase中指定的数据重新更新插入的一张新表中，实现数据迁移。 需求场景：     将所有info列簇中的所有name这列导入到另一张表中去，通过Java对MapReduce操作Hbase实现数据迁移建表：     读取的表： create 'stu_mr','info','degree','work'   ...
Hbase使用CopyTable进行数据复制和迁移
月月大王的博客
02-25 3764
最近有一个需求，是将Hbase表中的数据复制到另一张表中，因为Hbase的数据比较多，通过java程序读出来然后再向数据库中插入的话，是不太现实了，只能寻找另外的工具，搜了一下原来Hbase自身就提供了相应的组件，那就是 CopyTable。 简单的记录一下使用过程 1、创建两张表 create 'test01' ,'name' create 'test02' ,'name' 2、向表中插入数据 put 'test01' , '001','name:n' ,'xiaomin...
mapreduce复制连接的代码_mit 6.824 学习笔记 (一) MapReduce 详解
weixin_39799825的博客
11-21 159
原文发布于邹扒皮实验室0x00 序本来前年的这个时候就打算刷这个课了，但是在抗击懒癌的过程中节节败退。一直就拖到了现在，也不知道这次能坚持多久。总之争取每个月能出一篇文章吧。主要是为了克服自己对于知识的遗忘，如果同时能给你带来一些启发或者帮助那就更好了。考虑到自己吃了没文化的亏，为了能在某些时候能读到最新的一些技术文章或者论文。现在就必须克服读英语的障碍，我会强迫自己去理解并翻译原文，参考其他文章...
使用mapreduce操作Hbase
成都往右的博客
11-01 1090
前面用了java api操作了hbase，这里就用mapreduce来操作mapreduce。
使用Mapreduce获取HBASE表中一行数据
04-23
您可以使用Hadoop的MapReduce框架来获取HBase表中的一行数据。以下是基本步骤： 1.编写一个Mapper类，使用HBase API从表中获取一行数据。 2.编写一个Reducer类，将Mapper类中获取的一行数据输出到输出文件中。 3....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值