第3章 序列化与压缩 3.1序列化

最新推荐文章于 2020-12-04 01:32:48 发布
最新推荐文章于 2020-12-04 01:32:48 发布
阅读量236 收藏
点赞数
文章标签： java 大数据 python

《Hadoop技术内幕：深入解析Hadoop Common和HDFS架构设计与实现原理》第3章序列化与压缩，本章涉及了org.apache.hadoop.io包下最重要的两部分内容：序列化和压缩。本节为大家介绍序列化。

第3章　序列化与压缩

传统的计算机系统通过I/O操作与外界进行交流，Hadoop的I/O由传统的I/O系统发展而来，但又有些不同，Hadoop需要处理P、T级别的数据，所以在org.apache.hadoop.io包中包含了一些面向海量数据处理的基本输入输出工具，本章会对其中的序列化和压缩进行研究。

3.1　序列化

对象的序列化（Serialization）用于将对象编码成一个字节流，以及从字节流中重新构建对象。“将一个对象编码成一个字节流”称为序列化该对象（Serializing）；相反的处理过程称为反序列化（Deserializing）。

序列化有三种主要的用途：

作为一种持久化格式：一个对象被序列化以后，它的编码可以被存储到磁盘上，供以后反序列化用。

作为一种通信数据格式：序列化结果可以从一个正在运行的虚拟机，通过网络被传递到另一个虚拟机上。

作为一种拷贝、克隆（clone）机制：将对象序列化到内存的缓存区中，然后通过反序列化，可以得到一个对已存对象进行深拷贝的新对象。

在分布式数据处理中，主要使用上面提到的前两种功能：数据持久化和通信数据格式。

在分析Hadoop的序列化机制前，先介绍一下Java内建的序列化机制。

3.1.1　Java内建序列化机制

Java序列化机制将对象转换为连续的byte数据，这些数据可以在日后还原为原先的对象状态，该机制还能自动处理不同操作系统上的差异，在Windows系统上序列化的Java对象，可以在UNIX系统上被重建出来，不需要担心不同机器上的数据表示方法，也不需要担心字节排列次序，如大端（big endian）、小端（little endian）或其他细节。

在Java中，使一个类的实例可被序列化非常简单，只需要在类声明中加入implements Serializable即可。Serializable接口是一个标志，不具有任何成员函数，其定义如下：

 

  1. publicinterfaceSerializable{ 
  2. }
 

 Serializable接口没有任何方法，所以不需要对类进行修改，Block类通过声明它实现了Serializable接口，立即可以获得Java提供的序列化功能。代码如下：
 

 
 

 

  1. publicclassBlockimplementsWritable,Comparable<Block>,Serializable
 

 由于序列化主要应用在与I/O相关的一些操作上，其实现是通过一对输入/输出流来实现的。如果想对某个对象执行序列化动作，可以在某种OutputStream对象（后面还会讨论Java的流）的基础上创建一个对象流ObjectOutputStream对象，然后调用writeObject()就可达到目的。
 

 writeObject()方法负责写入实现了Serializable接口对象的状态信息，输出数据将被送至该OutputStream。多个对象的序列化可以在ObjectOutputStream对象上多次调用writeObject()，分别写入这些对象。下面是序列化一个Block对象的例子：
 

 
 

 

  1. Blockblock1=newBlock(7806259420524417791L,39447755L,56736651L); 
  2.  Blockblock2=newBlock(5547099594945187683L,67108864L,56736828L);  
  3. …… 
  4.  ByteArrayOutputStreamout=newByteArrayOutputStream();  
  6. //在ByteArrayOutputStream的基础上创建ObjectOutputStream 
  7.  ObjectOutputStreamobjOut=newObjectOutputStream(out);  
  9. //对block进行序列化 
  10. objOut.writeObject(block1); 
 

 对于Java基本类型的序列化，ObjectOutputStream提供了writeBoolean()、writeByte()等方法。
 

 输入过程类似，将InputStream包装在ObjectInputStream中并调用readObject()，该方法返回一个指向向上转型后的Object的引用，通过向下转型，就可以得到正确结果。读取对象时，必须要小心地跟踪存储的对象的数量、顺序以及它们的类型。
 

 Java的序列化机制非常“聪明”，JavaDoc中对ObjectOutputStream的writeObject()方法的说明是：“……这个对象的类、类签名、类的所有非暂态和非静态成员的值，以及它所有的父类都要被写入”，序列化机制会自动访问对象的父类，以保证对象内容的一致性。同时，序列化机制不仅存储对象在内存中的原始数据，还会追踪通过该对象可以到达的其他对象的内部数据，并描述所有这些对象是如何被链接起来的。对于复杂的情形，Java序列化机制也能应付自如：在输出objectA和objectB时，不会重复保存对象的序列化结果（如objectC，即objectC只被序列化一次）；对于循环引用的对象，序列化也不会陷入死循环（如图3-1右图的情形）。
 

 
 

 
 

 但是，序列化以后的对象在尺寸上有点过于充实了，以Block类为例，它只包含3个长整数，但是它的序列化结果竟然有112字节，而BlockMetaDataInfo其实只多了一个long型的成员变量，输出结果已经膨胀到190字节。包含3个长整数的Block对象的序列化结果如下：
 

 
 

 

  1. ACED00057372001C6F72672E6861646F....sr..org.hado 
  2. 6F70696E7465726E616C2E7365722E42opinternal.ser.B 
  3. 6C6F636BE780E3D3A6B622530200034Alock......"S...J 
  4. 0007626C6F636B49644A000F67656E65..blockIdJ..gene 
  5. 726174696F6E5374616D704A00086E75rationStampJ..nu 
  6. 6D427974657378706C55679568E792FFmBytesxplUg.h... 
  7. 000000000361BB8B000000000259ECCB.....a.......Y..
 

 仔细看Block的输出会发现，序列化的结果中包含了大量与类相关的信息。Java的序列过程在《Java Object Serialization Specification》中规范，以Block为例，其结果的前两个字节是魔数（Magic Number）“AC ED”；后续两个字节是序列化格式的版本号，现在使用的版本号是5；接下来是类的描述信息，包括类的版本ID、是否实现writeObject()和readObject()方法等信息，对于拥有超类的类（如BlockMetaDataInfo），超类的信息也会递归地被保存下来；这些信息都写入OutputStream对象后，接下来才是对象的数据。在这个过程中，序列化输出中保存了大量的附加信息，导致序列化结果膨胀，对于需要保存和处理大规模数据的Hadoop来说，需要一个新的序列化机制。
 

 由于篇幅的关系，不再详细讨论Java的序列化机制，有兴趣的读者可以参考《Java Object Serialization Specification》。
 

 3.1.2　Hadoop序列化机制
 

 和Java序列化机制不同（在对象流ObjectOutputStream对象上调用writeObject()方法），Hadoop的序列化机制通过调用对象的write()方法（它带有一个类型为DataOutput的参数），将对象序列化到流中。反序列化的过程也是类似，通过对象的readFields()，从流中读取数据。值得一提的是，Java序列化机制中，反序列化过程会不断地创建新的对象，但在Hadoop的序列化机制的反序列化过程中，用户可以复用对象：如，在Block的某个对象上反复调用readFields()，可以在同一个对象上得到多个反序列化的结果，而不是多个反序列化的结果对象（对象被复用了），这减少了Java对象的分配和回收，提高了应用的效率。
 

 
 

 

  1. publicstaticvoidmain(String[]args){ 
  2. try{ 
  3.  Blockblock1=newBlock(7806259420524417791L,39447755L,56736651L);  
  4. …… 
  5.  ByteArrayOutputStreambout=newByteArrayOutputStream();  
  6.  DataOutputStreamdout=newDataOutputStream(bout);  
  7. block1.write(dout);//序列化对象到输出流dout中 
  8. dout.close(); 
  9. System.out.println(……); 
  10. SerializationExample.print16(out.toByteArray(),bout.size()); 
  11. } 
  12. …… 
  13. }
 

 由于Block对象序列化时只输出了3个长整数， block1的序列化结果一共有24字节，如下所示。和Java的序列化机制的输出结果对比，Hadoop的序列化结果紧凑而且快速。
 

 
 

 

  1. ACED0005737200286F72672E6861646F....sr.(org.hado 
  2. 6F70696E7465726Eopintern 
 

 3.1.3　Hadoop序列化机制的特征
 

 对于处理大规模数据的Hadoop平台，其序列化机制需要具有如下特征：
 

 紧凑：由于带宽是Hadoop集群中最稀缺的资源，一个紧凑的序列化机制可以充分利用数据中心的带宽。
 

 快速：在进程间通信（包括MapReduce过程中涉及的数据交互）时会大量使用序列化机制，因此，必须尽量减少序列化和反序列化的开销。
 

 可扩展：随着系统的发展，系统间通信的协议会升级，类的定义会发生变化，序列化机制需要支持这些升级和变化。
 

 互操作：可以支持不同开发语言间的通信，如C++和Java间的通信。这样的通信，可以通过文件（需要精心设计文件的格式）或者后面介绍的IPC机制实现。
 

 Java的序列化机制虽然强大，却不符合上面这些要求。Java Serialization将每个对象的类名写入输出流中，这导致了Java序列化对象需要占用比原对象更多的存储空间。同时，为了减少数据量，同一个类的对象的序列化结果只输出一份元数据，并通过某种形式的引用，来共享元数据。引用导致对序列化后的流进行处理的时候，需要保持一些状态。想象如下一种场景，在一个上百G的文件中，反序列化某个对象，需要访问文件中前面的某一个元数据，这将导致这个文件不能切割，并通过MapReduce来处理。同时，Java序列化会不断地创建新的对象，对于MapReduce应用来说，不能重用对象，在已有对象上进行反序列化操作，而是不断创建反序列化的各种类型记录，这会带来大量的系统开销。
 

 3.1.4　Hadoop Writable机制
 

 为了支持以上这些特性，Hadoop引入org.apache.hadoop.io.Writable接口，作为所有可序列化对象必须实现的接口，其类图如图3-2所示。
 

 
 

 
 

 Writable机制紧凑、快速（但不容易扩展到Java以外的语言，如C、Python等）。和java.io.Serializable不同，Writable接口不是一个说明性接口，它包含两个方法：
 

 
 

 

  1. publicinterfaceWritable{ 
  2. /** 
  3. *输出（序列化）对象到流中 
  4. *@paramoutDataOuput流，序列化的结果保存在流中 
  5. *@throwsIOException 
  6. */ 
  7. voidwrite(DataOutputout)throwsIOException; 
  9. /** 
  10. *从流中读取（反序列化）对象 
  11. *为了效率，请尽可能复用现有的对象 
  12. *@paraminDataInput流，从该流中读取数据 
  13. *@throwsIOException 
  14. */ 
  15. voidreadFields(DataInputin)throwsIOException; 
  16. } 
 

 Writable.write()方法用于将对象状态写入二进制的DataOutput中，反序列化的过程由readFields()从DataInput流中读取状态完成。下面是一个例子：
 

 
 

 

  1. publicclassBlockimplementsWritable,Comparable<Block>,Serializable{ 
  2. …… 
  3. privatelongblockId; 
  4. privatelongnumBytes; 
  5. privatelonggenerationStamp; 
  6. …… 
  7. publicvoidwrite(DataOutputout)throwsIOException{ 
  8. out.writeLong(blockId); 
  9. out.writeLong(numBytes); 
  10. out.writeLong(generationStamp); 
  11. } 
  13. publicvoidreadFields(DataInputin)throwsIOException{ 
  14.  this.blockId=in.readLong();  
  15.  this.numBytes=in.readLong();  
  16.  this.generationStamp=in.readLong();  
  17.  if(numBytes<0){  
  18. thrownewIOException("Unexpectedblocksize:"+numBytes); 
  19. } 
  20. } 
  21. …… 
  22. } 
 

 这个例子使用的是前面分析Java序列化机制的Block类，Block实现了Writable接口，即需要实现write()方法和readFields()方法，这两个方法的实现都很简单：Block有三个成员变量，write()方法简单地把这三个变量写入流中，而readFields()则从流中依次读入这些数据，并做必要的检查。
 

 Hadoop序列化机制中还包括另外几个重要接口：WritableComparable、RawComparator和WritableComparator。
 

 WritableComparable，顾名思义，它提供类型比较的能力，这对MapReduce至关重要。该接口继承自Writable接口和Comparable接口，其中Comparable用于进行类型比较。ByteWritable、IntWritable、DoubleWritable等Java基本类型对应的Writable类型，都继承自WritableComparable。
 

 效率在Hadoop中非常重要，因此HadoopI/O包中提供了具有高效比较能力的RawComparator接口。RawComparator和WritableComparable类图如图3-3所示。
 

 
 

 RawComparator接口允许执行者比较流中读取的未被反序列化为对象的记录，从而省去了创建对象的所有开销。其中，compare()比较时需要的两个参数所对应的记录位于字节数组b1和b2的指定开始位置s1和s1，记录长度为l1和l2，代码如下：
 

 
 

 

  1. publicinterfaceRawComparator<T>extends 
  2.  Comparator<T>{  
  3. publicintcompare(byte[]b1,ints1,intl1,byte[]b2,ints2,intl2); 
  4. }
 

 以IntWritable为例，它的RawComparator实现中（WritableComparator是一个辅助类，实现了RawComparator接口），compare()方法通过readInt()直接在字节数组中读入需要比较的两个整数，然后输出Comparable接口要求的比较结果。值得注意的是，该过程中compare()方法避免使用IntWritable对象，从而避免了不必要的对象分配。相关代码如下：
 

 
 

 

  1. publicstaticclassComparatorextendsWritableComparator{ 
  2. …… 
  3. publicintcompare(byte[]b1,ints1,intl1, 
  4. byte[]b2,ints2,intl2){ 
  5.  intthisValue=readInt(b1,s1);  
  6.  intthatValue=readInt(b2,s2);  
  7.  return(thisValue<thatValue?-1:(thisValue==thatValue?0:1));  
  8. } 
  9. …… 
  10. }
 

 WritableComparator是RawComparator对WritableComparable类的一个通用实现。它提供两个主要功能。首先，提供了一个RawComparator的compare()默认实现，该实现从数据流中反序列化要进行比较的对象，然后调用对象的compare()方法进行比较（这些对象都是Comparable的）。其次，它充当了RawComparator实例的一个工厂方法，例如，可以通过如下代码获得IntWritable的RawComparator：
 

 
 

 

  1. RawComparator<IntWritable>comparator= 
  2.  WritableComparator.get(IntWritable.class);  
 

 3.1.5　典型的Writable类详解（1）
 

 Hadoop将很多Writable类归入org.apache.hadoop.io包中，类图如图3-4所示。
 

 
 

 
 

 在这些类中，比较重要的有Java基本类、Text、Writable集合、ObjectWritable等，本节重点介绍Java基本类和ObjectWritable的实现。
 

 1. Java基本类型的Writable封装
 

 目前Java基本类型对应的Writable封装如表3-1所示。所有这些Writable类都继承自WritableComparable。也就是说，它们是可比较的。同时，它们都有get()和set()方法，用于获得和设置封装的值。
 

 表3-1　Java基本类型对应的Writable封装
 

 
 

 
 

 在表3-1中，对整型（int和long）进行编码的时候，有固定长度格式（IntWritable和LongWritable）和可变长度格式（VIntWritable和VLongWritable）两种选择。固定长度格式的整型，序列化后的数据是定长的，而可变长度格式则使用一种比较灵活的编码方式，对于数值比较小的整型，它们往往比较节省空间。同时，由于VIntWritable和VLongWritable的编码规则是一样的，所以VIntWritable的输出可以用VLongWritable读入。下面以VIntWritable为例，说明Writable的Java基本类封装实现。代码如下：
 

 
 

 

  1. publicclassVIntWritableimplementsWritableComparable{ 
  2. privateintvalue; 
  3. …… 
  4. //设置VIntWritable的值 
  5.  publicvoidset(intvalue){this.value=value;}  
  7. //获取VIntWritable的值 
  8. publicintget(){returnvalue;} 
  10. publicvoidreadFields(DataInputin)throwsIOException{ 
  11.  value=WritableUtils.readVInt(in);  
  12. } 
  14. publicvoidwrite(DataOutputout)throwsIOException{ 
  15. WritableUtils.writeVInt(out,value); 
  16. } 
  17. …… 
  18. } 
 

 首先，每个Java基本类型的Writable封装，其类的内部都包含一个对应基本类型的成员变量value，get()和set()方法就是用来对该变量进行取值/赋值操作的。而Writable接口要求的readFields()和write()方法，VIntWritable则是通过调用Writable工具类中提供的readVInt()和writeVInt()读/写数据。方法readVInt()和writeVInt()的实现也只是简单调用了readVLong()和writeVLong()，所以，通过writeVInt()写的数据自然可以通过readVLong()读入。
 

 writeVLong ()方法实现了对整型数值的变长编码，它的编码规则如下：
 

 如果输入的整数大于或等于–112同时小于或等于127，那么编码需要1字节；否则，序列化结果的第一个字节，保存了输入整数的符号和后续编码的字节数。符号和后续字节数依据下面的编码规则（又一个规则）：
 

 如果是正数，则编码值范围落在–113和–120间（闭区间），后续字节数可以通过–(v+112)计算。
 

 如果是负数，则编码值范围落在–121和–128间（闭区间），后续字节数可以通过–(v+120)计算。
 

 3.1.5　典型的Writable类详解（2）
 

 后续编码将高位在前，写入输入的整数（除去前面全0字节）。代码如下：
 

 
 

 

  1. publicfinalclassWritableUtils{ 
  2. publicstaticvoidwriteVInt(DataOutputstream,inti)throwsIOException 
  3. { 
  4. writeVLong(stream,i); 
  5. } 
  7. /** 
  8. *@paramstream保存系列化结果输出流 
  9. *@parami被序列化的整数 
  10. *@throwsjava.io.IOException 
  11. */ 
  12. publicstaticvoidwriteVLong(DataOutputstream,longi)throws…… 
  13. { 
  14. //处于[-112,127]的整数 
  15.  if(i>=-112&&i<=127){  
  16. stream.writeByte((byte)i); 
  17. return; 
  18. } 
  19. //计算情况2的第一个字节 
  20.  intlen=-112;  
  21.  if(i<0){  
  22. i^=-1L; 
  23.  len=-120;  
  24. } 
  26.  longtmp=i;  
  27. while(tmp!=0){ 
  28.  tmptmp=tmp>>8;  
  29. len--; 
  30. } 
  32. stream.writeByte((byte)len); 
  34.  len=(len<-120)?-(len+120):-(len+112);  
  36. //输出后续字节 
  37.  for(intidx=len;idx!=0;idx--){  
  38.  intshiftbits=(idx-1)*8;  
  39.  longmask=0xFFL<<shiftbits;  
  40.  stream.writeByte((byte)((i&mask)>>shiftbits));  
  41. } 
  42. } 
  43. } 
 

 注意　本书附带代码对writeVLong()的输出结果做了一些分析，有兴趣的读者可以运行org.hadoopinternal.ser.VLongShow，分析一些典型整数的writeVLong()输出结果。
 

 2. ObjectWritable类的实现
 

 针对Java基本类型、字符串、枚举、Writable、空值、Writable的其他子类，ObjectWritable提供了一个封装，适用于字段需要使用多种类型。ObjectWritable可应用于Hadoop远程过程调用（将在第4章介绍）中参数的序列化和反序列化；ObjectWritable的另一个典型应用是在需要序列化不同类型的对象到某一个字段，如在一个SequenceFile的值中保存不同类型的对象（如LongWritable值或Text值）时，可以将该值声明为ObjectWritable。
 

 ObjectWritable的实现比较冗长，需要根据可能被封装在ObjectWritable中的各种对象进行不同的处理。ObjectWritable有三个成员变量，包括被封装的对象实例instance、该对象运行时类的Class对象和Configuration对象。
 

 ObjectWritable的write方法调用的是静态方法ObjectWritable.writeObject()，该方法可以往DataOutput接口中写入各种Java对象。
 

 writeObject()方法先输出对象的类名（通过对象对应的Class 对象的getName()方法获得），然后根据传入对象的类型，分情况系列化对象到输出流中，也就是说，对象通过该方法输出对象的类名，对象序列化结果对到输出流中。在ObjectWritable.writeObject()的逻辑中，需要分别处理null、Java数组、字符串String、Java基本类型、枚举和Writable的子类6种情况，由于类的继承，处理Writable时，序列化的结果包含对象类名，对象实际类名和对象序列化结果三部分。
 

 3.1.5　典型的Writable类详解（3）
 

 为什么需要对象实际类名呢？根据Java的单根继承规则，ObjectWritable中传入的declaredClass，可以是传入instance对象对应的类的类对象，也可以是instance对象的父类的类对象。但是，在序列化和反序列化的时候，往往不能使用父类的序列化方法（如write方法）来序列化子类对象，所以，在序列化结果中必须记住对象实际类名。相关代码如下：
 

 
 

 

  1. publicclassObjectWritableimplementsWritable,Configurable{ 
  2. privateClassdeclaredClass;//保存于ObjectWritable的对象对应的类对象 
  3. privateObjectinstance;//被保留的对象 
  4. privateConfigurationconf; 
  6. publicObjectWritable(){} 
  8. publicObjectWritable(Objectinstance){ 
  9. set(instance); 
  10. } 
  12. publicObjectWritable(ClassdeclaredClass,Objectinstance){ 
  13.  this.declaredClass=declaredClass;  
  14.  this.instance=instance;  
  15. } 
  16. …… 
  17. publicvoidreadFields(DataInputin)throwsIOException{ 
  18. readObject(in,this,this.conf); 
  19. } 
  21. publicvoidwrite(DataOutputout)throwsIOException{ 
  22. writeObject(out,instance,declaredClass,conf); 
  23. } 
  24. …… 
  25. publicstaticvoidwriteObject(DataOutputout,Objectinstance, 
  26. ClassdeclaredClass,Configurationconf)throws……{ 
  28.  if(instance==null){//空  
  29.  instance=newNullInstance(declaredClass,conf);  
  30.  declaredClass=Writable.class;  
  31. } 
  33. //写出declaredClass的规范名 
  34. UTF8.writeString(out,declaredClass.getName()); 
  36. if(declaredClass.isArray()){//数组 
  37. …… 
  38.  }elseif(declaredClass==String.class){//字符串  
  39. …… 
  40. }elseif(declaredClass.isPrimitive()){//基本类型 
  41.  if(declaredClass==Boolean.TYPE){//boolean  
  42. out.writeBoolean(((Boolean)instance).booleanValue()); 
  43.  }elseif(declaredClass==Character.TYPE){//char  
  44. …… 
  45. } 
  46. }elseif(declaredClass.isEnum()){//枚举类型 
  47. …… 
  48. }elseif(Writable.class.isAssignableFrom(declaredClass)){ 
  49. //Writable的子类 
  50. UTF8.writeString(out,instance.getClass().getName()); 
  51. ((Writable)instance).write(out); 
  52. }else{ 
  53. …… 
  54. } 
  56. publicstaticObjectreadObject(DataInputin, 
  57. ObjectWritableobjectWritable,Configurationconf){ 
  58. …… 
  59.  ClassinstanceClass=null;  
  60. …… 
  61.  Writablewritable=WritableFactories.newInstance(instanceClass,  
  62. conf); 
  63. writable.readFields(in); 
  64.  instance=writable;  
  65. …… 
  66. } 
  67. } 
 

 和输出对应，ObjectWritable的readFields()方法调用的是静态方法ObjectWritable.readObject ()，该方法的实现和writeObject()类似，唯一值得研究的是Writable对象处理部分，readObject ()方法依赖于WritableFactories类。WritableFactories类允许非公有的Writable子类定义一个对象工厂，由该工厂创建Writable对象，如在上面的readObject ()代码中，通过WritableFactories的静态方法newInstance()，可以创建类型为instanceClass的Writable子对象。相关代码如下：
 

 

  1. publicclassWritableFactories{ 
  2. //保存了类型和WritableFactory工厂的对应关系 
  3.  privatestaticfinalHashMap<Class,WritableFactory>CLASS_TO_FACTORY 
  4.  =newHashMap<Class,WritableFactory>();  
  5. …… 
  6.  publicstaticWritablenewInstance(Class<?extendsWritable>c,  
  7. Configurationconf){ 
  8.  WritableFactoryfactory=WritableFactories.getFactory(c);  
  9. if(factory!=null){ 
  10.  Writableresult=factory.newInstance();  
  11. if(resultinstanceofConfigurable){ 
  12. ((Configurable)result).setConf(conf); 
  13. } 
  14. returnresult; 
  15. }else{ 
  16. //采用传统的反射工具ReflectionUtils，创建对象 
  17. returnReflectionUtils.newInstance(c,conf); 
  18. } 
  19. } 
  20. }
 

 3.1.5　典型的Writable类详解（4）
 

 WritableFactories.newInstance()方法根据输入的类型查找对应的WritableFactory工厂对象，然后调用该对象的newInstance()创建对象，如果该对象是可配置的，newInstance()还会通过对象的setConf()方法配置对象。
 

 WritableFactories提供注册机制，使得这些Writable子类可以将该工厂登记到WritableFactories的静态成员变量CLASS_TO_FACTORY中。下面是一个典型的WritableFactory工厂实现，来自于HDFS的数据块Block。其中，WritableFactories.setFactory()需要两个参数，分别是注册类对应的类对象和能够构造注册类的WritableFactory接口的实现，在下面的代码里，WritableFactory的实现是一个匿名类，其newInstance()方法会创建一个新的Block对象。
 

 
 

 

  1. publicclassBlockimplementsWritable,Comparable<Block>{ 
  2. static{ 
  3. WritableFactories.setFactory 
  4. (Block.class,//类对象 
  5. newWritableFactory(){//对应类的WritableFactory实现 
  6. publicWritablenewInstance(){returnnewBlock();} 
  7. }); 
  8. } 
  9. …… 
  10. }
 

 ObjectWritable作为一种通用机制，相当浪费资源，它需要为每一个输出写入封装类型的名字。如果类型的数量不是很多，而且可以事先知道，则可以使用一个静态类型数组来提高效率，并使用数组索引作为类型的序列化引用。GenericWritable就是因为这个目的被引入org.apache.hadoop.io包中，由于篇幅关系，不再详细介绍，有兴趣的读者可以继续分析GenericWritable的源代码。
 

 3.1.6　Hadoop序列化框架
 

 大部分的MapReduce程序都使用Writable键–值对作为输入和输出，但这并不是Hadoop的API指定的，其他序列化机制也能和Hadoop配合，并应用于MapReduce中。
 

 目前，除了前面介绍过的Java序列化机制和Hadoop使用的Writable机制，还流行其他序列化框架，如Hadoop Avro、Apache Thrift和Google Protocol Buffer。
 

 Avro是一个数据序列化系统，用于支持大批量数据交换的应用。它的主要特点有：支持二进制序列化方式，可以便捷、快速地处理大量数据；动态语言友好，Avro提供的机制使动态语言可以方便地处理 Avro数据。
 

 Thrift是一个可伸缩的、跨语言的服务开发框架，由Facebook贡献给开源社区，是Facebook的核心框架之一。基于Thrift的跨平台能力封装的Hadoop文件系统Thrift API（参考contrib的thriftfs模块），提供了不同开发语言开发的系统访问HDFS的能力。
 

 Google Protocol Buffer是Google内部的混合语言数据标准，提供了一种轻便高效的结构化数据存储格式。目前，Protocol Buffers提供了C++、Java、Python三种语言的API，广泛应用于Google内部的通信协议、数据存储等领域中。
 

 Hadoop提供了一个简单的序列化框架API，用于集成各种序列化实现，该框架由Serialization实现（在org.apache.hadoop.io.serializer包中）。
 

 Serialization是一个接口，使用抽象工厂的设计模式，提供了一系列和序列化相关并相互依赖对象的接口。通过Serialization应用可以获得类型的Serializer实例，即将一个对象转换为一个字节流的实现实例；Deserializer实例和Serializer实例相反，它用于将字节流转为一个对象。很明显，Serializer和Deserializer相互依赖，所以必须通过抽象工厂Serialization，才能获得对应的实现。相关代码如下：
 

 
 

 

  1. publicinterfaceSerialization<T>{ 
  3. //客户端用于判断序列化实现是否支持该类对象 
  4.  booleanaccept(Class<?>c);  
  6. //获得用于序列化对象的Serializer实现 
  7.  Serializer<T>getSerializer(Class<T>c);  
  9. //获得用于反序列化对象的Deserializer实现 
  10.  Deserializer<T>getDeserializer(Class<T>c);  
  11. } 
 

 如果需要使用Serializer来执行序列化，一般需要通过open()方法打开Serializer，open()方法传入一个底层的流对象，然后就可以使用serialize()方法序列化对象到底层的流中。最后序列化结束时，通过close()方法关闭Serializer。Serializer接口的相关代码如下：
 

 
 

 

  1. publicinterfaceSerializer<T>{ 
  2. //为输出（序列化）对象做准备 
  3. voidopen(OutputStreamout)throwsIOException; 
  5. //将对象序列化到底层的流中 
  6. voidserialize(Tt)throwsIOException; 
  8. //序列化结束，清理 
  9. voidclose()throwsIOException; 
  10. } 
 

 Hadoop目前支持两个Serialization实现，分别是支持Writable机制的WritableSerialization和支持Java序列化的JavaSerialization。通过JavaSerialization可以在MapReduce程序中方便地使用标准的Java类型，如int或String，但如同前面所分析的，Java的Object Serialization不如Hadoop的序列化机制有效，非特殊情况不要轻易尝试。
 


                

        

        




    

  


    

      

        

            

              
                
                  海兰
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
序列化和压缩

				
			

			

				

					m0_47130698的博客
				

				

					09-14
					
					699
					
				

			

		

		

			
				
hadoop需要处理P、T级别的数据，所以在org.apache.hadoop.io中包含一些面向海量数据处理的基本工具。

1、序列化
对象的序列化（Serialization）用于将对象编码成一个字节流，以及从字节流中重新构建一个对象。相反的，处理过程称为反序列化（Deserializing）
序列化有三种主要的用途：


作为一种持久化格式，一个对象被序列化后，他的编码可以被存储在磁盘上，供以后反序列化使用
作为一种通信数据格式：序列化结果可以从一个虚拟机通过网络传到另一个虚拟机上
作为一种拷贝，克隆

			
		

	



                

            
              



	

		

			

				
					
Protobuf 编码及序列化的记录

				
			

			

				

					u014209688的专栏
				

				

					06-02
					
					7190
					
				

			

		

		

			
				
工作中用到了protobuf，然后之前在面试的时候面试官就问了一个问题，如果将int32类型的字段的值设置为0，那还会将该值进行序列化吗？当时是懵了的，因为自己还没有研究这部分。当时给的结果是不会，猜测protobuf中int32的默认值是0，既然默认值是0的，那应该就不会进行序列化了。

   那次面试之后就觉得自己应该了解一下这部分了，结果这两天了解完之后，发现自己猜错了。好记...

			
		

	



              


  
              

                


	

		

			

				
					
序列化压缩实现及对比测试

				
			

			

				

					weixin_34050389的博客
				

				

					11-06
					
					430
					
				

			

		

		

			
				
网上介绍序列化压缩的用gzip比较多。写个测试代码，测试一下四种序列化方式：

无压缩
zlib压缩
gzip压缩
zip压缩


测例结果显示压缩效果：gzip压缩 &gt; zlib压缩 &gt; zip压缩 &gt; 无压缩
测例结果显示压缩速度：zlib压缩 &gt; gzip压缩 &gt; zip压缩 = 无压缩
确实用gzip性价比比较高！

zlib、gzip、zip介绍

1. z...

			
		

	





	

		

			

				
					
序列化与压缩

				
			

			

				

					konstantin的博客
				

				

					08-17
					
					2174
					
				

			

		

		

			
				
对象的序列化（Serialization）用于将对象编译成一个字节流，以及从字节流里重新构建对象，将一个对象编码成一个字节流为欸序列化该对象；相反处理为反序列化（Deserializing）；
序列化有三种主要途径：
作为一种持久化格式：一个对象序列化以后他的编码吗可以存储在磁盘上；供以以后反序列化使用；
作为一种通信数据格式：序列化结果可以从一个正在运行的虚拟机通过网络被传递到另一个虚拟机

			
		

	



		

			
		



	

		

			

				
					
序列化数据传输压缩

				
			

			

				

					qq_36797488的博客
				

				

					12-04
					
					1474
					
				

			

		

		

			
				
1.名词解释

1.1序列化

序列化的数据传输时以一定格式传输

例：


struct data{
    int64 data1;
    int64 data2;
    char data3[25];
}

但传输的数据实际上data1和data2大部分数据都是非常小的，只有极少数的数据会用到64位数据来进行保存，这种时候本博客的传输压缩算法就有用武之地。

1.2 1248码:

在表示十进制数时计算机除了二进制编码之外还有一种编码方式叫做1248码，其用4位二进制数表示一位10进制数。使用的地

			
		

	





	

		

			

				
					
HTTP_序列化和压缩

				
			

			

				

					03-17
				

			

		

		

			
				
The advent of .NET Framework is the most significant event in the programming world over the last 10 years and I think it is still underestimated. It is the most solid and comprehensive framework ever. However, nothing and nobody is perfect. This article is about .NET Framework communication and compact framework communication (serialization) in particular.

			
		

	





	

		

			

				
					
Java中的序列化与反序列化

				
			

			

				

					
				

			

		

		

			
				
# 第一章：序列化与反序列化概述  ## 1.1 什么是序列化与反序列化  ## 1.2 序列化与反序列化在Java中的应用场景  ## 1.3 序列化与反序列化的基本原理 ## 第二章：Java中的序列化  2.1 如何在Java中实现对象的序列化 ...

			
		

	





	

		

			

				
					
序列化与反序列化

				
			

			

				

					
				

			

		

		

			
				
 什么是序列化与反序列化  ## 1.1 序列化的定义和概念 在软件开发中，序列化是指将对象的状态信息转换为可以存储或传输的格式的过程。这些格式可以是字节流、JSON、XML等。通过序列化，对象可以被保存到文件中，或者...

			
		

	





	

		

			

				
					
对象的序列化与反序列化：JDK中序列化机制的5个深度理解

				
			

			

				

					
				

			

		

		

			
				
序列化与反序列化是计算机编程中用于将对象状态转换为可存储或传输的格式的过程。对象的序列化主要是为了便于在不同环境下，如内存和数据库，或者在分布式系统中的不同主机之间传输或存储。反序列化则是将这些格式的...

			
		

	





	

		

			

				
					
序列化和Zip压缩

				
			

			

				

					07-10
				

			

		

		

			
				
本Dll提供了二进制序列化和Xml序列化，序列化之后，可以对序列化数据，进行压缩。本dll提供了两种压缩方式，GZipStream和DeflateStream，在使用Webservice作为服务端的系统中，提高传输性能是比较关键的，而提高传输性能，对传输数据进行压缩是很重要的方法。 
     使用.Net自带压缩算法，压缩率很大，压缩和解压的速度很快。本dll对于需要使用远程数据传输的系统中，非常有用。先序列化，然后压缩，客户端解压之后，反序列化，还原数据。

			
		

	





	

		

			

				
					
Java对象序列化框架Kryo.zip

				
			

			

				

					07-17
				

			

		

		

			
				
Kryo 是一个快速高效的Java对象图形序列化框架，主要特点是性能、高效和易用。该项目用来序列化对象到文件、数据库或者网络。示例代码：Kryo kryo = new Kryo();
// ...
Output output = new Output(new FileOutputStream("file.bin"));
SomeClass someObject = ...
kryo.writeObject(output, someObject);
output.close();
// ...
Input input = new Input(new FileInputStream("file.bin"));
SomeClass someObject = kryo.readObject(input, SomeClass.class);
input.close();API文档：http://tool.oschina.net/apidocs/apidoc?api=kyro-2.21
                        
                        
                            标签：Kryo

			
		

	





	

		

			

				
					
自己实现的protobuf 压缩类，并能序列化反序列化

				
			

			

				

					09-19
				

			

		

		

			
				
自己实现的protobuf 压缩类，并能序列化反序列化

			
		

	





	

		

			

				
					
通俗易懂——Java对象的序列化Serializable

				
			

			

				

					weixin_46002478的博客
				

				

					10-14
					
					200
					
				

			

		

		

			
				
Java中的序列化机制

Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
序列化

类 ObjectInputStream 和 ObjectOutputStream 是高层次的数据流，它们包含反序列化和序列化对象的方法。

特别的，一个类的对象

			
		

	





	

		

			

				
					
序列化、压缩、解压缩、反序列化对象

				
			

			

				

					记事本
				

				

					07-29
					
					1674
					
				

			

		

		

			
				
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Data;using System.Runtime.Serialization.Formatters.Binary;using System.IO;using System.IO.C

			
		

	





	

		

			

				
					
（7）序列化与压缩

				
			

			

				

					華華的博客
				

				

					09-13
					
					1317
					
				

			

		

		

			
				
因为ServiceObject的函数签名格式是统一的，可以传递的参数只有一个AParams:OLEVariant，客户端的多个参数需要使用数组传递。如：var  vParams:OLEVariant;  vResult:integer;begin  ...  vParams:=VarArrayCreate([0,1],varVariant);  vParams[0]:=

			
		

	





	

		

			

				
					
序列化及压缩

				
			

			

				

					weixin_30814223的博客
				

				

					06-04
					
					128
					
				

			

		

		

			
				
public static byte[] DataSetSerializerCompression(DataSet ds) //这里我是将一个DataSet序列化及压缩,最后以byte形式返回 {  IFormatter formatter = new BinaryFormatter();//定义BinaryFormatter以序列化DataSet对象 
...

			
		

	





	

		

			

				
					
Hadoop源码分析笔记(二)：Hadoop序列化与压缩

				
			

			

				

					Keep moving
				

				

					05-28
					
					1251
					
				

			

		

		

			
				
Hadoop文件序列化
        本文着重讲述Hadoop面向海量数据处理的输入输出。代码请见org.apache.hadoop.io包。
序列化用途
        对象的序列化是用于将对象编码成一个字节流，以及从字节流中重新够着对象。
        一般来说，序列化有以下三种主要用途：
        一、作为一种持久化格式：一个对象被序列化以后，它的编码可以被存储到磁盘中，

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值