Hadoop学习笔记之三 数据流向
http://hadoop.apache.org/docs/r1.2.1/api/index.html
最基本的：
1. 文本文件的解析
2. 序列文件的解析
toString会将Byte数组中的内存数据 按照字节间隔以字符的形式显示出来。
文本文件多事利用已有的字符处理类， 序列文件多事创建byte数组，然后将文件流中的数据复制到byte数组后进行解析。
LineRecordReader。。。 。。。
这里首先需要了整个文件数据 的流动方向。
MapReduce框架借助inputformat完成输入数据的规范检查，借助outputformat完成输出数据的规范性检查。
context的常用用法：
context.getConfiguration
context.getInputSplit
context.write
利用好context可以随心所欲的输出，从输入key value list中获得信息，输出可以是单个的key，value；也可以是key list
从输入中获得信息，用context随便向外写！
一个Mapper对应一个Split文件，而recorderreder需要多次调用用来解析键值对：
如下所示一个文本文件传入mapper，而map函数多次被触发
public class TestDataFlow { public static void main(String[] args)throws Exception{ Configuration conf = new Configuration(); Job job = new Job(conf, "testDataFlow"); job.setJarByClass(TestDataFlow.class); job.setMapperClass(myMapper.class); FileInputFormat.addInputPath(job, new Path("hdfs://MASTERPC:9000/home/Fea.txt")); FileOutputFormat.setOutputPath(job, new Path("hdfs://MASTERPC:9000/out")); job.waitForCompletion(true); } public static class myMapper extends Mapper<Object, Text, Text, Text>{ private FileSplit split; public void map(Object key, Text value, Context context) throws IOException, InterruptedException{ split = (FileSplit)context.getInputSplit(); System.out.println("输入文件块的路径："+split.getPath().toString()); } } } 14/11/09 17:15:44 INFO mapred.MapTask: Processing split: hdfs://MASTERPC:9000/home/Fea.txt:0+7397 输入文件块的路径：hdfs://MASTERPC:9000/home/Fea.txt 输入文件块的路径：hdfs://MASTERPC:9000/home/Fea.txt 输入文件块的路径：hdfs://MASTERPC:9000/home/Fea.txt 输入文件块的路径：hdfs://MASTERPC:9000/home/Fea.txt 输入文件块的路径：hdfs://MASTERPC:9000/home/Fea.txt 输入文件块的路径：hdfs://MASTERPC:9000/home/Fea.txt 输入文件块的路径：hdfs://MASTERPC:9000/home/Fea.txt 输入文件块的路径：hdfs://MASTERPC:9000/home/Fea.txt
下面是一段自定义InputFormat的程序，功能是将零碎的小文件合并成大的sequence文件：key文件名，value文件值
//主要包括两个部分：文件划分 + 创建RecordReader； 下面的代码new了一个自己的reader返回
public class myFileInputFormat extends FileInputFormat<NullWritable, BytesWritable> { protected boolean isSplitable(JobContext context, Path file){ return false; } public RecordReader<NullWritable, BytesWritable> createRecordReader(InputSplit split, TaskAttemptContext context) throws IOException,InterruptedException{ myRecordReader recorder = new myRecordReader(); recorder.initialize(split, context); return recorder; } }
//使用split获得输入文件块的大小、路径信息；使用context获得fs真正的从dfs上读入文件内容到value成员变量中。
//成员变量value用来传递给Mapper的map函数使用public class myRecordReader extends RecordReader<NullWritable, BytesWritable> { private FileSplit split; private Configuration conf; private BytesWritable value = new BytesWritable(); private boolean processed = false; public void initialize(InputSplit split, TaskAttemptContext context) throws IOException, InterruptedException { this.split = (FileSplit)split; this.conf = context.getConfiguration(); } public void close(){ ; } public NullWritable getCurrentKey()throws IOException{ return null; } public BytesWritable getCurrentValue()throws IOException{ return value; } public float getProgress()throws IOException, InterruptedException{ return processed?1.0f:0.0f; } public boolean nextKeyValue()throws IOException, InterruptedException{ if (!processed){ byte[] buf = new byte[(int)split.getLength()]; FileSystem fs = FileSystem.get(conf); Path path = split.getPath(); InputStream in = null; try{ in = fs.open(path); IOUtils.readFully(in, buf, 0, buf.length); value.set(buf,0, buf.length); }finally{ IOUtils.closeStream(in); } processed = true; return true; }else{ return false; } } } //RecordReader处理好的key和value自动的传递给map函数
public static class myMapper extends Mapper<Object, BytesWritable, Text, BytesWritable>{ private FileSplit split; private Text outkey = new Text(); public void setup(Context context){ split = (FileSplit)context.getInputSplit(); outkey.set(split.getPath().toString()); System.out.println("输入文件块的路径："+split.getPath().toString()); } public void map(Object key, BytesWritable value, Context context) throws IOException, InterruptedException{ System.out.println("key: "+ outkey.toString()+" value: "+value.toString()); }
Mapper类对应的是输入的文件块split，map对应的是文件块解析出来的一个个的<key, value>
RecordReader对应的是输入的文件块split，可能需要多次对split进行解析。
InputFormat中分为两部分，getSplit是将inputPath路径下的HDFS文件划分成块split，另一部分是CreateRecordReader
创建用来解析每个split。
其中划分成块是在终端上传数据文件时进行的，然后划分之后的文件信息提供给jobTracker进行分配，分配到任务的节点（Mapper）到相应的 位置下载自己的split文件
然后调用RecordReader不断对这个split文件进行解析，将生成的<key,value>送给map函数进行处理生成新的<key,value>,经过排序合并分组之后传递给相应的reduce。
自定义InputFormat
下面是一个将小文件聚合成大的序列文件的mapred作业，核心是利用自定义的FileInputFormt将系统分配的小文件，以文件名（text）key，
文件内容（bytes）value的键值对形式传递给最后的SeqenceFileOutputFormat，将这些键值对写入HDFS上的序列文件中。
由于文件较小所以不会再分块，一个文件作为整体输入到节点上，FileInputFormat中设置文件不可分。
Mapper类中调用FileInputFormat中的创建初始化RecordReader函数：createRecordReader（），
RecordReader将输入文件解析后将<key，value>送给map函数， 在之前的TextInputFormat的LineRecordReader是不断的对split进行处理
将每行解析成一个<key, value>送给map，但是这里的应用时RecordReader仅仅处理split文件一次，就将整个文件的内容作为<null, value>
传递给map， 最后的reduce在将所有的键值对聚合成一个。所以RecordReader类中做了处理次数的判断处理。
这样一来对于每个节点的map也只会执行一次，多以在Mapper一开始的时候setup函数中将输入的Split文件的文件名获得作为key。
文件：myRecordReader.java
[说明]RecordReader的作用就是为了解析split文件，所以createRecordReader时传入的参数是split、context，在RecordReader类中，首先需要获得
HDFS上的split的输入文件流，然后对此进行解析，并记录下处理的位置，方便下次map调用的时候，从上次的位置接着对split文件进行解析。
文件：myFileInputFormat.java
[说明]该类中设置文件不可分，创建RecordReader对象。
inputFormat和 recordReader中的键值对类型一定要和 map中的键值对类型一致。
作业上下文context可以获得作业参数conf、输入文件InputSplit、
在Mapper类的初始化函数中传入的参数就是context
public void setup(Context context)
OutputFormat：
主要的函数是：
getRcordWriter, 返回的是RecordWriter， 它负责将键值对写入到存储部件中。
checkOutputSpecs,负责检查输出目录参数是否合理，如果输出目录已经存在就报错。
getOutputCommiter，OutputCommiter负责临时文件的初始化，作业完成之后清理临时目录等等。
系统默认的是TextOutputFormat，它使用LineRecordWriter将最终获的键值对以key + \t + value的方式逐行输出到文本文件中。
在 编程时使用较多的是重载 writer、RecordWriter、getRecordWriter，
tips：在eclipse中代码的空白处右键->Source->Override/Implements Methods 然后在弹出的窗口中选择需要重载的成员方法。^.^
（生成的重载函数上面会自动生@Override灰色字体）
下面是hadoop源码SequenceFileOutputFormat中的一段：
public RecordWriter<K, V>
getRecordWriter(TaskAttemptContext context
) throws IOException, InterruptedException {
。。。 。。。
final SequenceFile.Writer out = SequenceFile.createWriter(fs, conf, file, context.getOutputKeyClass(), context.getOutputValueClass(), compressionType, codec, context); return new RecordWriter<K, V>() { public void write(K key, V value) throws IOException { out.append(key, value); } public void close(TaskAttemptContext context) throws IOException { out.close(); } };
可见write中传入的是OutputFormat<K，V>中的键值对，而创建的SequenceFile.Writer是根据setOutputKeyClass、setOutputValueClass设置的类型进行写文件。
public class TestFormat {public static void main(String[] args)throws Exception{ Configuration conf = new Configuration(); Job job = new Job(conf, "testFormat!"); job.setInputFormatClass(SequenceFileInputFormat.class); job.setOutputFormatClass(SequenceFileOutputFormat.class); FileInputFormat.addInputPath(job , new Path("hdfs://master:9000/hadoop")); FileOutputFormat.setOutputPath(job, new Path("hdfs://master:9000/out")); job.waitForCompletion(true); } }
java.lang.Exception: java.io.IOException:
Type mismatch in key from map: expected org.apache.hadoop.io.LongWritable, recieved org.apache.hadoop.io.Text
job.setOutputKeyClass(Text.class); job.setOutputValueClass(BytesWritable.class);
RecordReader是根据输入文件中的内容自动获得key和value的class，所以map之后的k，v类型是原始文件的kv类型，但是write函数中out（writer）的kv类型时job中设置的。
//草稿：
public static class myOutputFormat<Text, BytesWritable> extends SequenceFileOutputFormat<Text, BytesWritable>{ public RecordWriter<Text, BytesWritable> getRecordWriter( TaskAttemptContext arg0) throws IOException, InterruptedException { // TODO Auto-generated method stub return super.getRecordWriter(arg0); } }
定义自己的数据：
public class Point3D implements WritableComparable<Point3D>{ private float x, y, z; public float getX(){return x;} public float getY(){return y;} public float getZ(){return z;} public void readFields(DataInput in) throws IOException{ x = in.readFloat(); y = in.readFloat(); z = in.readFloat(); } public void write(DataOutput out)throws IOException{ out.writeFloat(x); out.writeFloat(y); out.writeFloat(z); } public int compareTo(Point3D p){ float ret = (x*x+y*y +z*z) - (p.x*(p.x)+p.y*(p.y)+p.z*(p.z)); if (ret > 0) return 1; else if (ret == 0) return 0; else return -1; } }
一些常用的流：
FSDataInputStream
DataInputStream
FileInputStream
InputStream
BufferedInputStream
链式处理：
在hadoop计算的过程中比较耗费时间的是IO操作，一些Job 在Map需要前期预处理，reduce后需要后处理，这样可以使用Job的链式处理；
通过ChainMapper.addMapp实现，但是该类不支持hadoop1.2.1版本。
---------------------------------------------------------------
参考文献：
《实战Hadoop》开启通向云计算的捷径，刘鹏主编，电子工业出版社
最短路径系列之一《从零开始学Hadoop》
http://blog.csdn.net/chaoping315/article/details/6221440
