HBase概念学习（七）HBase与Mapreduce集成

这篇文章是看了HBase权威指南之后，依据上面的解说搬下来的样例，可是略微有些不一样。

HBase与mapreduce的集成无非就是mapreduce作业以HBase表作为输入，或者作为输出，也或者作为mapreduce作业之间共享数据的介质。

这篇文章将解说两个样例：

1、读取存储在hdfs上的txt文本数据，简单地以json字符串的形式存储到HBase表中。

2、将第一步存储的HBase表中的json字符串读取出来，解析存储到新的HBase表中，能够进行查询。

本文具体给出了源代码以及怎样执行，旨在加深HBase与mapreduce集成的学习。

假设你还不知道怎么搭建基于HDFS的HBase单机环境，以及怎样执行mapreduce任务，那么请先參考我这两篇文章：

(1) HBase环境搭建（一）Ubuntu下基于Hadoop文件系统的单机模式

(2) Hadoop基础学习（一）分析、编写并执行WordCount词频统计程序

1、读取存储在hdfs上的txt文本数据，简单地以json字符串的形式存储到HBase表中。

源代码：

/**
 * @author 季义钦
 * @date 2014-6
 * @reference HBase权威指南 chapter7
 * 
 */

import java.io.IOException;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableOutputFormat;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class HdfsToHBase 
{
	private static final Log LOG = LogFactory.getLog(HdfsToHBase.class);
	public static final String NAME = "ImportFromFile";
	public enum Counters { LINES }
	  
	/**
	 * Map类
	 *
	 */
	static class ImportMapper 
	extends Mapper<LongWritable, Text, ImmutableBytesWritable, Writable>
	{
		private byte[] family = null;
		private byte[] qualifier = null;
		
		@Override
		protected void setup(Context context) throws IOException, InterruptedException
		{
			//获取通过Configuration传过来的列名
			String columns = context.getConfiguration().get("conf.column");
			
			//解析出列族和列的名称
			byte[][] columnsBytes = KeyValue.parseColumn(Bytes.toBytes(columns));
			family = columnsBytes[0];
			qualifier = columnsBytes[1];
			
			LOG.info("family:"+family.toString()+"qualifiers:"+qualifier);
		}
		
		@Override
		public void map(LongWritable offset, Text line, Context context) throws IOException
		{
			try
			{
				String lineStr = line.toString();
				byte[] rowkey = DigestUtils.md5(lineStr);
				
				//构造Put对象
				Put put = new Put(rowkey);
				put.add(family, qualifier, Bytes.toBytes(lineStr));
				
				//发射Put对象
				context.write(new ImmutableBytesWritable(rowkey), put);
				context.getCounter(Counters.LINES).increment(1);
				
			}catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		
	}
	
	/**
	 * 将命令行參数解析为HBase的CommandLine对象
	 * @param args
	 * @return
	 * @throws ParseException
	 */
	private static CommandLine parseArgs(String[] args) throws ParseException
	{
		Options options = new Options();
	    Option o = new Option("t", "table", true, "table to import into (must exist)");
	    o.setArgName("table-name");
	    o.setRequired(true);
	    options.addOption(o);
	    
	    o = new Option("c", "column", true, "column to store row data into (must exist)");
	    o.setArgName("family:qualifier");
	    o.setRequired(true);
	    options.addOption(o);
	    
	    o = new Option("i", "input", true, "the directory or file to read from");
	    o.setArgName("path-in-HDFS");
	    o.setRequired(true);
	    options.addOption(o);
	    
	    CommandLineParser parser = new PosixParser();
	    CommandLine cmd = null;
	    
	    try 
	    {
	        cmd = parser.parse(options, args);
	    } catch (Exception e) {
	        System.err.println("ERROR: " + e.getMessage() + "
");
	        HelpFormatter formatter = new HelpFormatter();
	        formatter.printHelp(NAME + " ", options, true);
	        System.exit(-1);
	    }
	    
	    return cmd;
	}
	
	/**
	 * 主函数
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception
	{
		//将输入參数解析为CommandLine对象
		Configuration conf = HBaseConfiguration.create();
	    String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
	    CommandLine cmd = parseArgs(otherArgs);
	    
	    //取出各项參数
	    String tableName = cmd.getOptionValue("t");
	    String inputFileName = cmd.getOptionValue("i");
	    String columnName = cmd.getOptionValue("c");
	    conf.set("conf.column", columnName);
	    
	    Job job = new Job(conf, "Import from file " + inputFileName + " into table " + tableName);
	    job.setJarByClass(HdfsToHBase.class);
	    
	    //设置map和reduce类
	    job.setMapperClass(ImportMapper.class);
	    job.setNumReduceTasks(0);
	    
	    //设置map阶段输出的键值对类型
	    job.setOutputKeyClass(ImmutableBytesWritable.class);
	    job.setOutputValueClass(Writable.class);
	    
	    //设置job输入输出格式
	    job.setOutputFormatClass(TableOutputFormat.class);
	    job.getConfiguration().set(TableOutputFormat.OUTPUT_TABLE, tableName);	    
	    
	    //设置输入输出路径
	    FileInputFormat.addInputPath(job, new Path(inputFileName));
	    
	    System.exit(job.waitForCompletion(true) ? 0 : 1);
	}
}

引入的jar文件包含：

这是在eclispe中开发的，放在默认的包以下，导出为普通的jar文件。

然后利用命令start-all.sh和start-hbase.sh分别启动hadoop和HBase。

（1）首先登陆HBase shell，创建一个仅仅包括一个列族的表：

（2）然后将txt数据上传到HDFS上面（数据在HBase权威指南随书的源代码包中有）。

（3）然后运行job：

当中指定了main函数所在的类名，然后就各自是habse 表名，hdfs文件名称，hbase表的列名。

作业运行完毕之后能够到：http://localhost:50030/jobtracker.jsp 查看作业运行状态。

然后能够登陆hbase shell查看article表中有多少行数据，也能够用scan所有打印出来看。

2、将第一步存储的HBase表中的json字符串读取出来，解析存储到新的HBase表中，能够进行查询。

源代码：

/**
 * @author 季义钦
 * @date 2014-6
 * @reference HBase权威指南 chapter7
 * 
 */
import java.io.IOException;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
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.client.Scan;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.IdentityTableReducer;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.hbase.mapreduce.TableMapper;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.util.GenericOptionsParser;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;

public class HBaseToHBase 
{
	private static final Log LOG = LogFactory.getLog(HBaseToHBase.class);
	public static final String NAME = "HBaseToHBase";
	public enum Counters { ROWS, COLS, ERROR, VALID }
	
	/**
	 * Map类
	 * 以HBase表作为输入，所以继承自TableMapper
	 *
	 */
	static class ParseMapper
	extends TableMapper<ImmutableBytesWritable, Writable>
	{
		private JSONParser parser = new JSONParser();
		private byte[] family = null;
		
		@Override
		protected void setup(Context context) throws IOException, InterruptedException
		{
			family = Bytes.toBytes(context.getConfiguration().get("conf.family"));
		}
		
		@Override 
		public void map(ImmutableBytesWritable rowKey, Result columns, Context context) throws IOException
		{
			String value = null;		
			
			try
			{
				String author = "null";
				Put put = new Put(rowKey.get());
				
				//循环取得每一列(这里实际上仅仅有一列存储json字符串)
				for(KeyValue kv:columns.list())
				{
					context.getCounter(Counters.COLS).increment(1);
					value = Bytes.toStringBinary(kv.getValue());
					
					//解析获取的json字符串
					JSONObject json = (JSONObject)parser.parse(value);
					for(Object key : json.keySet())
					{						
						Object val = json.get(key);
						if(key.equals("author"))
						{
							author = val.toString();
						}
						
						put.add(family, Bytes.toBytes(key.toString()), Bytes.toBytes(val.toString()));						
					}					
				}
				
				//以解析到的author作为行键发射出去
				context.write(new ImmutableBytesWritable(Bytes.toBytes(author)), put);
				context.getCounter(Counters.VALID).increment(1);
				LOG.info("存储作者 "+author+"的数据完毕!");
			}catch(Exception e)
			{
				e.printStackTrace();
				System.err.println("Error: " + e.getMessage() + ", Row: " +
				          Bytes.toStringBinary(rowKey.get()) + ", JSON: " + value);
				        context.getCounter(Counters.ERROR).increment(1);
			}
		}
	}
	
	/**
	 * 解析命令行參数
	 * @param args
	 * @return
	 * @throws ParseException
	 */
	private static CommandLine parseArgs(String[] args) throws ParseException 
	{
		Options options = new Options();
	    
		Option o = new Option("i", "input", true, "table to read from (must exist)");
		o.setArgName("input-table-name");
		o.setRequired(true);
		options.addOption(o);
	    
	    o = new Option("ic", "column", true, "column to read data from (must exist)");
	    o.setArgName("family:qualifier");
	    o.setRequired(true);
	    options.addOption(o);
	    
	  	o = new Option("o", "output", true, "table to write to (must exist)");
	  	o.setArgName("output-table-name");
	  	o.setRequired(true);
	  	options.addOption(o);
	    
	    o = new Option("oc", "family", true, "cf to write data to (must exist)");
	    o.setArgName("family");
	    o.setRequired(true);
	    options.addOption(o);
	    
	    CommandLineParser parser = new PosixParser();
	    CommandLine cmd = null;
	    try 
	    {
	      cmd = parser.parse(options, args);
	    } 
	    catch (Exception e) 
	    {
	      System.err.println("ERROR: " + e.getMessage() + "
");
	      HelpFormatter formatter = new HelpFormatter();
	      formatter.printHelp(NAME + " ", options, true);
	      System.exit(-1);
	    }
	    return cmd;
	  }
	
	/**
	 * 主函数
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
	    Configuration conf = HBaseConfiguration.create();
	    String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
	    CommandLine cmd = parseArgs(otherArgs);
	    
	    String inputTable = cmd.getOptionValue("i");	//HBase源表
	    String outputTable = cmd.getOptionValue("o");	//HBase目标表
	    String inputColumn = cmd.getOptionValue("ic");	//HBase源表的列名
	    String outputColumnFamily = cmd.getOptionValue("oc");	//HBase目标表的列族名
	    conf.set("conf.family", outputColumnFamily);    
	    
	    //提供Scan实例指定要扫描的列
	    Scan scan = new Scan();
	    byte[][] colkey = KeyValue.parseColumn(Bytes.toBytes(inputColumn));	    	
	    scan.addColumn(colkey[0], colkey[1]);	        
	    
	    Job job = new Job(conf, "Parse data in " + inputTable + ", write to " + outputTable);
	    job.setJarByClass(HBaseToHBase.class);  
	    
	    //高速配置作业以HBase作为输入源和输出源
	    TableMapReduceUtil.initTableMapperJob(inputTable, scan, ParseMapper.class, ImmutableBytesWritable.class, Put.class, job);
	    TableMapReduceUtil.initTableReducerJob(outputTable, IdentityTableReducer.class, job);

	    System.exit(job.waitForCompletion(true) ? 0 : 1);
	}

}

注意：

（1）以HBase表作为mapreduce作业的输入时，一方面要继承字TableMapper类，一方面须要提供一个scan实例，指定要扫描来作为输入的记录。

（2）当中配置的Reduce是IdentityTableReducer，其作用和IdentityTableMapper一样，仅仅是简单地将键值对传递到下一个阶段而已，没有什么实质性作用，它对于数据存储到HBase表中不是必须的，全然能够用另外一句话替代，即： setNumReduceTasks（0）.

实际上作业运行的时候你应该也能够看到reduce一直是0%。

引入的jar文件包含：

（1）创建HBase表：

（2）导出jar包：

注意：里面引入了一个第三方的jar包，即simple json的jar包，用于解析json字符串。

simple json jar文件在这里下载：http://www.java2s.com/Code/Jar/j/Downloadjsonsimple111jar.htm

之前在一个站点下了一个山寨的，结果没有parse(string)这个接口，仅仅有parse(Reader)这个接口，将String转换成StringReader传进去结果作业老是报错，坑死了。

引入第三方jar包运行Mapreduce作业的时候会报出classnotFound的异常，解决方法有下面几种：

1.把要依赖的包部署到每台tasktracker上面

这种方法最简单，可是要部署到每台tasktracker，并且可能引起包污染的问题。比方应用A和应用B都用到同一个libray，可是版本号不同，就会出现冲突的问题。

2.把依赖的包和直接合并到mapreducejob的包

这种方法的问题是合并后的包可能很大，也不利于的包的升级

3.使用DistributedCache

这种方法就是先把这些包上传到HDFS,能够在程序启动的时候做一次。然后在submitjob的时候把hdfspath加到classpath里面。
演示样例：

$bin/hadoop fs -copyFromLocal ib/protobuf-java-2.0.3.jar/myapp/protobuf-java-2.0.3.jar //Setup the application's JobConf:JobConf job = new JobConf(); DistributedCache.addFileToClassPath(newPath("/myapp/protobuf-java-2.0.3.jar"), job);

4，另一种情况是扩展包特别多的情况下用3就不爽了，參考一下：

《Hadoop权威指南》中也有关于jar打包的处理措施，查找之

【不论什么非独立的JAR文件都必须打包到JAR文件的lib文件夹中。（这与Java的webapplication archive或WAR文件类似，不同的是，后者的JAR文件放在WEB-INF/lib子文件夹下的WAR文件里）】

我採用的是第四种方法，在project以下创建一个lib目录，将json-simple-1.1.1.jar放进去：

然后export：

（3）运行job：

OK了，以下就能够用hbase shell登陆，并用scan ‘authorTable’查看解析进去的数据了。