hadoop编程小技巧（5）---自定义输入文件格式类InputFormat

Hadoop代码测试环境：Hadoop2.4

应用：在对数据需要进行一定条件的过滤和简单处理的时候可以使用自定义输入文件格式类。

Hadoop内置的输入文件格式类有：

1）FileInputFormat<K,V>这个是基本的父类，我们自定义就直接使用它作为父类；

2）TextInputFormat<LongWritable,Text>这个是默认的数据格式类，我们一般编程，如果没有特别指定的话，一般都使用的是这个；key代表当前行数据距离文件开始的距离，value代码当前行字符串；

3）SequenceFileInputFormat<K,V>这个是序列文件输入格式，使用序列文件可以提高效率，但是不利于查看结果，建议在过程中使用序列文件，最后展示可以使用可视化输出；

4）KeyValueTextInputFormat<Text,Text>这个是读取以Tab（也即是 ）分隔的数据，每行数据如果以 分隔，那么使用这个读入，就可以自动把 前面的当做key，后面的当做value；

5）CombineFileInputFormat<K,V>合并大量小数据是使用；

6）MultipleInputs，多种输入，可以为每个输入指定逻辑处理的Mapper；

原理：

InputFormat接口有两个重要的函数:

1)getInputSplits，用于确定输入分片，当我们继承FileInputFormat时，就可以忽略此函数，而使用FileInputFormat的此函数即可；

2）createRecordReader ，针对数据如何读取的类，定义输入文件格式，其实也就是定义此类；

在每个map函数中，最开始调用的都是nextKeyValue()函数，这个函数就是在RecordReader中定义的（我们自定义RecordReader就是使用不同的实现而已），所以这里会调用我们指定的RecordReader中的nextKeyValue函数。这个函数就会处理或者说是初始化key和value，然后返回true，告知已经处理好了。接着就会调用getCurrentKey 和getCurrentValue获取当前的key和value值。最后，返回map，继续执行map逻辑。

自定义输入文件格式类：

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package fz.inputformat;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import org.apache.hadoop.io.Text;  
  6. import org.apache.hadoop.mapreduce.InputSplit;  
  7. import org.apache.hadoop.mapreduce.RecordReader;  
  8. import org.apache.hadoop.mapreduce.TaskAttemptContext;  
  9. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
  10. /** 
  11.  * 自定义输入文件读取类 
  12.  *  
  13.  * @author fansy 
  14.  * 
  15.  */  
  16. public class CustomInputFormat extends FileInputFormat<Text, Text> {  
  17.   
  18.     @Override  
  19.     public RecordReader<Text, Text> createRecordReader(InputSplit split,  
  20.             TaskAttemptContext context) throws IOException,  
  21.             InterruptedException {  
  22.         // TODO Auto-generated method stub  
  23.         return new CustomReader();  
  24.     }  
  25. }  

这里看到如果继承了FileInputFormat 后，就不需要关心getInputSplits了，而只需要定义RecordReader即可。

自定义RecordReader

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package fz.inputformat;  
  2.   
  3. //import java.io.BufferedReader;  
  4. import java.io.IOException;  
  5.   
  6. import org.apache.hadoop.conf.Configuration;  
  7. import org.apache.hadoop.fs.FSDataInputStream;  
  8. import org.apache.hadoop.fs.FileSystem;  
  9. import org.apache.hadoop.fs.Path;  
  10. import org.apache.hadoop.io.Text;  
  11. import org.apache.hadoop.mapreduce.InputSplit;  
  12. import org.apache.hadoop.mapreduce.RecordReader;  
  13. import org.apache.hadoop.mapreduce.TaskAttemptContext;  
  14. import org.apache.hadoop.mapreduce.lib.input.FileSplit;  
  15. import org.apache.hadoop.util.LineReader;  
  16.   
  17. public  class CustomReader extends RecordReader<Text ,Text>{  
  18. //  private BufferedReader in;  
  19.     private LineReader lr ;  
  20.     private Text key = new Text();  
  21.     private Text value = new Text();  
  22.     private long start ;  
  23.     private long end;  
  24.     private long currentPos;  
  25.     private Text line = new Text();  
  26.     @Override  
  27.     public void initialize(InputSplit inputSplit, TaskAttemptContext cxt)  
  28.             throws IOException, InterruptedException {  
  29.         FileSplit split =(FileSplit) inputSplit;  
  30.         Configuration conf = cxt.getConfiguration();  
  31.         Path path = split.getPath();  
  32.         FileSystem fs = path.getFileSystem(conf);  
  33.         FSDataInputStream is = fs.open(path);  
  34.         lr = new LineReader(is,conf);  
  35.           
  36.         // 处理起始点和终止点  
  37.         start =split.getStart();  
  38.         end = start + split.getLength();  
  39.         is.seek(start);  
  40.         if(start!=0){  
  41.             start += lr.readLine(new Text(),0,  
  42.                     (int)Math.min(Integer.MAX_VALUE, end-start));  
  43.         }  
  44.         currentPos = start;  
  45.     }  
  46.   
  47.     // 针对每行数据进行处理  
  48.     @Override  
  49.     public boolean nextKeyValue() throws IOException, InterruptedException {  
  50.         if(currentPos > end){  
  51.             return false;  
  52.         }  
  53.         currentPos += lr.readLine(line);  
  54.         if(line.getLength()==0){  
  55.             return false;  
  56.         }  
  57.         if(line.toString().startsWith("ignore")){  
  58.             currentPos += lr.readLine(line);  
  59.         }  
  60.           
  61.         String [] words = line.toString().split(",");  
  62.         // 异常处理  
  63.         if(words.length<2){  
  64.             System.err.println("line:"+line.toString()+".");  
  65.             return false;  
  66.         }  
  67.         key.set(words[0]);  
  68.         value.set(words[1]);  
  69.         return true;  
  70.           
  71.     }  
  72.   
  73.     @Override  
  74.     public Text getCurrentKey() throws IOException, InterruptedException {  
  75.         return key;  
  76.     }  
  77.   
  78.     @Override  
  79.     public Text getCurrentValue() throws IOException, InterruptedException {  
  80.         return value;  
  81.     }  
  82.   
  83.     @Override  
  84.     public float getProgress() throws IOException, InterruptedException {  
  85.         if (start == end) {  
  86.             return 0.0f;  
  87.         } else {  
  88.             return Math.min(1.0f, (currentPos - start) / (float) (end - start));  
  89.         }  
  90.     }  
  91.   
  92.     @Override  
  93.     public void close() throws IOException {  
  94.         // TODO Auto-generated method stub  
  95.         lr.close();  
  96.     }  
  97.       
  98. }  

这里主要是两个函数，initial和nextKeyValue。

initial主要用于初始化，包括打开和读取文件，定义读取的进度等；

nextKeyValue则是针对每行数据（由于这里使用的是LineReader，所以每次读取的是一行，这里定义不同的读取方式，可以读取不同的内容），产生对应的key和value对，如果没有报错，则返回true。这里可以看到设置了一条规则，如果输入数据是以ignore开始的话就忽略，同时每行只取得逗号前后的数据分别作为key和value。

实战：

输入数据：

[plain] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. ignore,2  
  2. a,3  
  3. ignore,4  
  4. c,1  
  5. c,2,3,2  
  6. 4,3,2  
  7. ignore,34,2  

定义主类，主类的Mapper是默认的Mapper，没有reducer。

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package fz.inputformat;  
  2.   
  3. import org.apache.hadoop.conf.Configuration;  
  4. import org.apache.hadoop.conf.Configured;  
  5. import org.apache.hadoop.fs.Path;  
  6. import org.apache.hadoop.io.Text;  
  7. import org.apache.hadoop.mapreduce.Job;  
  8. import org.apache.hadoop.mapreduce.Mapper;  
  9. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
  10. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
  11. import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;  
  12. import org.apache.hadoop.util.Tool;  
  13. import org.apache.hadoop.util.ToolRunner;  
  14.   
  15.   
  16. public class FileInputFormatDriver extends Configured implements Tool{  
  17.   
  18.     /** 
  19.      * @param args 
  20.      * @throws Exception  
  21.      */  
  22.     public static void main(String[] args) throws Exception {  
  23.         // TODO Auto-generated method stub  
  24.         ToolRunner.run(new Configuration(), new FileInputFormatDriver(),args);  
  25.     }  
  26.   
  27.     @Override  
  28.     public int run(String[] arg0) throws Exception {  
  29.         if(arg0.length!=2){  
  30.             System.err.println("Usage: fz.inputformat.FileInputFormatDriver <in> <out>");  
  31.             return -1;  
  32.         }  
  33.         Configuration conf = getConf();  
  34.           
  35.         Path in = new Path(arg0[0]);  
  36.         Path out= new Path(arg0[1]);  
  37.         out.getFileSystem(conf).delete(out, true);  
  38.           
  39.         Job job = Job.getInstance(conf,"fileintputformat test job");  
  40.         job.setJarByClass(getClass());  
  41.           
  42.         job.setInputFormatClass(CustomInputFormat.class);  
  43.         job.setOutputFormatClass(TextOutputFormat.class);  
  44.           
  45.         job.setMapperClass(Mapper.class);  
  46.         job.setMapOutputKeyClass(Text.class);  
  47.         job.setMapOutputValueClass(Text.class);  
  48. //      job.setOutputKeyClass(LongWritable.class);  
  49. //      job.setOutputValueClass(VectorWritable.class);  
  50.         job.setNumReduceTasks(0);  
  51. //      System.out.println(job.getConfiguration().get("mapreduce.job.reduces"));  
  52. //      System.out.println(conf.get("mapreduce.job.reduces"));  
  53.         FileInputFormat.setInputPaths(job, in);  
  54.         FileOutputFormat.setOutputPath(job, out);  
  55.           
  56.         return job.waitForCompletion(true)?0:-1;  
  57.     }  
  58.   
  59. }  


查看输出：



这里可以看到，ignore的数据已经被忽略掉了，同时每行只输出了逗号前后的数据而已。

同时需要注意到：

这里有一行数据读入的是空字符串，这个暂时还没找到原因。

总结：自定义输入数据格式可以针对不同的数据做些过滤，进行一些简单的逻辑处理，有点类似map的功能，但是如果仅仅是这点功能的话，那完全可以使用map来取代了。其实输入数据格式还有其他的功能，比如合并大量的小数据，以提高效率，这个在下篇再说。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/hyl8218/p/5198030.html