Hadoop学习笔记之---Hadoop I/O

1. 数据完整性：任何语言对IO的操作都要保持其数据的完整性。hadoop当然希望数据在存储和处理中不会丢失或损坏。检查数据完整性的常用方法是校验和。

• HDFS的数据完整性：客户端在写或者读取HDFS的文件时，都会对其进行校验和验证，当然我们可以通过在Open（）方法读取之前，将false传给FileSystem中的setVerifyCheckSum()来禁用校验和。
• 本地文件系统，hadoop的本地文件系统执行客户端校验，这意味着，在写一个filename文件时，文件系统的客户端以透明方式创建了一个隐藏的文件.filename.crc,块的大小做为元数据存于此，所以读取文件时会进行校验和验证。
• ChecksumFileSystem：可以通过它对其数据验证。

2. 压缩：压缩后能够节省空间和减少网络中的传输。所以在hadoop中压缩是非常重要的。hadoop的压缩格式

压缩格式	算法	文件扩展名	多文件	可分割性
DEFLATEa	DEFLATE	.deflate	no	no
gzip（zip）	DEFLATE	.gz(.zip)	no(yes)	no(yes)
bzip2	bzip2	.bz2	no	yes
LZO	LZO	.lzo	no	no

• 编码/解码

Compression format          Hadoop CompressionCodec

DEFLATE                            org.apache.hadoop.io.compress.DefaultCodec

gzip                                   org.apache.hadoop.io.compress.GzipCodec

bzip2                                 org.apache.hadoop.io.compress.BZip2Codec

LZO                                   com.hadoop.compression.lzo.LzopCodec

可以用ComressionCodec轻松的压缩和解压缩。我们可以用 CompressionOutput 创建一个 CompressionOutputStream （未压缩的数据写到此）。相反，可以用compressionInputStream进行解压缩。

1. /** 
2.      * @param args 
3.      */  
4.     public static void main(String[] args) throws Exception  
5.     {  
6.         // TODO Auto-generated method stub  
7.         String codecClassname = args[0];  
8.         Class<?> codecClass = Class.forName(codecClassname);  
9.         Configuration configuration = new Configuration();  
10.         CompressionCodec codec = (CompressionCodec)ReflectionUtils.newInstance(codecClass, configuration);  
11.         CompressionOutputStream  outputStream = codec.createOutputStream(System.out);  
12.         IOUtils.copyBytes(System.in, outputStream, 4096,false);  
13.         outputStream.finish();  
14.     }  

• 压缩和分割：因为HDFS默认是以块的来存储数据的，所以在压缩时考虑是否支持分割时非常重要的。
• 在MapReduce使用压缩：例如要压缩MapReduce作业的输出，需要将配置文件中mapred.output.compress的属性设置为true

1. public static void main(String[] args) throws IOException {  
2.     if (args.length != 2) {  
3.       System.err.println("Usage: MaxTemperatureWithCompression <input path> " +  
4.             "<output path>");  
5.       System.exit(-1);  
6.     }  
7.       
8.     JobConf conf = new JobConf(MaxTemperatureWithCompression.class);  
9.     conf.setJobName("Max temperature with output compression");  
10.   
11.     FileInputFormat.addInputPath(conf, new Path(args[0]));  
12.     FileOutputFormat.setOutputPath(conf, new Path(args[1]));  
13.       
14.     conf.setOutputKeyClass(Text.class);  
15.     conf.setOutputValueClass(IntWritable.class);  
16.       
17.     /*[*/conf.setBoolean("mapred.output.compress", true);  
18.     conf.setClass("mapred.output.compression.codec", GzipCodec.class,  
19.         CompressionCodec.class);/*]*/  
20.   
21.     conf.setMapperClass(MaxTemperatureMapper.class);  
22.     conf.setCombinerClass(MaxTemperatureReducer.class);  
23.     conf.setReducerClass(MaxTemperatureReducer.class);  
24.   
25.     JobClient.runJob(conf);  
26.   }  

3.序列化：将字节流和机构化对象的转化。hadoop是进程间通信（RPC调用），PRC序列号结构特点：紧凑，快速，可扩展，互操作，hadoop使用自己的序列化格式Writerable，

• Writerable接口：  
  

1. package org.apache.hadoop.io;  
2. import java.io.DataOutput;  
3. import java.io.DataInput;  
4. import java.io.IOException;  
5. public interface Writable {  
6. void write(DataOutput out) throws IOException;// 将序列化流写入DataOutput  
7. void readFields(DataInput in) throws IOException; //从DataInput流读取二进制  
8. }  

1. package WritablePackage;  
2.   
3. import java.io.ByteArrayInputStream;  
4. import java.io.ByteArrayOutputStream;  
5. import java.io.DataInputStream;  
6. import java.io.DataOutputStream;  
7. import java.io.IOException;  
8.   
9.   
10. import org.apache.hadoop.io.Writable;  
11. import org.apache.hadoop.util.StringUtils;  
12. import org.hsqldb.lib.StringUtil;  
13.   
14. public class WritableTestBase  
15. {  
16.     public static byte[] serialize(Writable writable) throws IOException  
17.     {  
18.         ByteArrayOutputStream outputStream  = new ByteArrayOutputStream();  
19.         DataOutputStream dataOutputStream = new DataOutputStream(outputStream);  
20.         writable.write(dataOutputStream);  
21.         dataOutputStream.close();  
22.         return outputStream.toByteArray();  
23.     }  
24.       
25.     public static byte[] deserialize(Writable writable,byte[] bytes) throws IOException  
26.     {  
27.         ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);  
28.         DataInputStream dataInputStream = new DataInputStream(inputStream);  
29.         writable.readFields(dataInputStream);  
30.         dataInputStream.close();  
31.         return bytes;  
32.     }  
33.       
34.     public static String serializeToString(Writable src) throws IOException  
35.     {  
36.         return StringUtils.byteToHexString(serialize(src));  
37.     }  
38.       
39.     public static String writeTo(Writable src, Writable des) throws IOException  
40.     {  
41.         byte[] data = deserialize(des, serialize(src));  
42.         return StringUtils.byteToHexString(data);  
43.     }  
44. }  

 Writerable 类

Java primitive                  Writable implementation Serialized size (bytes)
boolean                           BooleanWritable 1
byte                                 ByteWritable 1
int                                    IntWritable 4
                                        VIntWritable 1–5
float                                FloatWritable 4
long                                LongWritable 8
                                       VLongWritable 1–9

4. 基于文件的数据结构

• SequenceFile类：是二进制键/值对提供一个持久化的数据结构。SequenceFile的读取和写入。

1. package WritablePackage;  
2.   
3. import java.io.IOException;  
4. import java.net.URI;  
5.   
6. import org.apache.hadoop.conf.Configuration;  
7. import org.apache.hadoop.fs.FileSystem;  
8. import org.apache.hadoop.fs.Path;  
9. import org.apache.hadoop.io.IOUtils;  
10. import org.apache.hadoop.io.IntWritable;  
11. import org.apache.hadoop.io.Text;  
12. import org.apache.hadoop.io.SequenceFile;  
13.   
14. public class SequenceFileWriteDemo  
15. {  
16.      private static final String[] DATA = {  
17.             "One, two, buckle my shoe",  
18.             "Three, four, shut the door",  
19.             "Five, six, pick up sticks",  
20.             "Seven, eight, lay them straight",  
21.             "Nine, ten, a big fat hen"  
22.           };  
23.   
24.     /** 
25.      * @param args 
26.      * @throws IOException  
27.      */  
28.     public static void main(String[] args) throws IOException  
29.     {  
30.         // TODO Auto-generated method stub  
31.         String url = args[0];  
32.         Configuration conf = new Configuration();  
33.         FileSystem fs = FileSystem.get(URI.create(url),conf);  
34.         Path path  = new Path(url);  
35.           
36.         IntWritable key = new IntWritable();  
37.         Text value = new Text();  
38.         SequenceFile.Writer writer =null;  
39.         try  
40.         {  
41.             writer = SequenceFile.createWriter(fs,conf,path,key.getClass(),value.getClass());  
42.               
43.             for(int i = 0; i< 100; i++)  
44.             {  
45.                 key.set(100-i);  
46.                 value.set(DATA[i%DATA.length]);  
47.                 System.out.printf("[%s]\t%s\t%s\n", writer.getLength(), key, value);  
48.                 writer.append(key,value);  
49.             }  
50.         }  
51.         catch (Exception e)  
52.         {  
53.             // TODO: handle exception  
54.         }  
55.         finally  
56.         {  
57.             IOUtils.closeStream(writer);  
58.         }  
59.     }  
60.   
61. }  

1. package WritablePackage;  
2.   
3. import java.io.IOException;  
4. import java.net.URI;  
5. import org.apache.hadoop.conf.Configuration;  
6. import org.apache.hadoop.fs.FileSystem;  
7. import org.apache.hadoop.fs.Path;  
8. import org.apache.hadoop.io.IOUtils;  
9. import org.apache.hadoop.io.SequenceFile;  
10. import org.apache.hadoop.io.Writable;  
11. import org.apache.hadoop.util.ReflectionUtils;  
12.   
13. public class SequenceFileReadDemo  
14. {  
15.   
16.     /** 
17.      * @param args 
18.      * @throws IOException  
19.      */  
20.     public static void main(String[] args) throws IOException  
21.     {  
22.         // TODO Auto-generated method stub  
23.         String url = args[0];  
24.         Configuration conf = new Configuration();  
25.         FileSystem  fs = FileSystem.get(URI.create(url),conf);  
26.         Path path = new Path(url);  
27.         SequenceFile.Reader reader = null;  
28.           
29.         try  
30.         {  
31.             reader = new SequenceFile.Reader(fs,path,conf);  
32.             Writable key =(Writable)ReflectionUtils.newInstance(reader.getKeyClass(), conf);  
33.             Writable value =(Writable) ReflectionUtils.newInstance(reader.getValueClass(), conf);  
34.             long position = reader.getPosition();  
35.               
36.             while(reader.next(key,value))  
37.             {  
38.                 String syncSeen = reader.syncSeen()? "*":"";  
39.                   System.out.printf("[%s%s]\t%s\t%s\n", position, syncSeen, key, value);  
40.                     position = reader.getPosition(); // beginning of next record  
41.             }  
42.         }  
43.         finally  
44.         {  
45.             IOUtils.closeStream(reader);  
46.         }  
47.     }  
48.   
49. }  

• MapFile  是经过排序的带索引的sequenceFile，可以根据键值进行查找，MapFile可以被任务是java.util.map一种持久化形式。注意它必须按顺序添加条目。